diff --git a/vendor/github.com/agext/levenshtein/DCO b/vendor/github.com/agext/levenshtein/DCO
new file mode 100644
index 000000000..716561d5d
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/DCO
@@ -0,0 +1,36 @@
+Developer Certificate of Origin
+Version 1.1
+
+Copyright (C) 2004, 2006 The Linux Foundation and its contributors.
+660 York Street, Suite 102,
+San Francisco, CA 94110 USA
+
+Everyone is permitted to copy and distribute verbatim copies of this
+license document, but changing it is not allowed.
+
+
+Developer's Certificate of Origin 1.1
+
+By making a contribution to this project, I certify that:
+
+(a) The contribution was created in whole or in part by me and I
+    have the right to submit it under the open source license
+    indicated in the file; or
+
+(b) The contribution is based upon previous work that, to the best
+    of my knowledge, is covered under an appropriate open source
+    license and I have the right under that license to submit that
+    work with modifications, whether created in whole or in part
+    by me, under the same open source license (unless I am
+    permitted to submit under a different license), as indicated
+    in the file; or
+
+(c) The contribution was provided directly to me by some other
+    person who certified (a), (b) or (c) and I have not modified
+    it.
+
+(d) I understand and agree that this project and the contribution
+    are public and that a record of the contribution (including all
+    personal information I submit with it, including my sign-off) is
+    maintained indefinitely and may be redistributed consistent with
+    this project or the open source license(s) involved.
diff --git a/vendor/github.com/agext/levenshtein/LICENSE b/vendor/github.com/agext/levenshtein/LICENSE
new file mode 100644
index 000000000..261eeb9e9
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/LICENSE
@@ -0,0 +1,201 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/github.com/agext/levenshtein/MAINTAINERS b/vendor/github.com/agext/levenshtein/MAINTAINERS
new file mode 100644
index 000000000..726c2afb3
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/MAINTAINERS
@@ -0,0 +1 @@
+Alex Bucataru <alex@alrux.com> (@AlexBucataru)
diff --git a/vendor/github.com/agext/levenshtein/NOTICE b/vendor/github.com/agext/levenshtein/NOTICE
new file mode 100644
index 000000000..eaffaab94
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/NOTICE
@@ -0,0 +1,5 @@
+Alrux Go EXTensions (AGExt) - package levenshtein
+Copyright 2016 ALRUX Inc.
+
+This product includes software developed at ALRUX Inc.
+(http://www.alrux.com/).
diff --git a/vendor/github.com/agext/levenshtein/README.md b/vendor/github.com/agext/levenshtein/README.md
new file mode 100644
index 000000000..90509c2a2
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/README.md
@@ -0,0 +1,38 @@
+# A Go package for calculating the Levenshtein distance between two strings
+
+[![Release](https://img.shields.io/github/release/agext/levenshtein.svg?style=flat)](https://github.com/agext/levenshtein/releases/latest)
+[![GoDoc](https://img.shields.io/badge/godoc-reference-blue.svg?style=flat)](https://godoc.org/github.com/agext/levenshtein) 
+[![Build Status](https://travis-ci.org/agext/levenshtein.svg?branch=master&style=flat)](https://travis-ci.org/agext/levenshtein)
+[![Coverage Status](https://coveralls.io/repos/github/agext/levenshtein/badge.svg?style=flat)](https://coveralls.io/github/agext/levenshtein)
+[![Go Report Card](https://goreportcard.com/badge/github.com/agext/levenshtein?style=flat)](https://goreportcard.com/report/github.com/agext/levenshtein)
+
+
+This package implements distance and similarity metrics for strings, based on the Levenshtein measure, in [Go](http://golang.org).
+
+## Project Status
+
+v1.2.1 Stable: Guaranteed no breaking changes to the API in future v1.x releases. Probably safe to use in production, though provided on "AS IS" basis.
+
+This package is being actively maintained. If you encounter any problems or have any suggestions for improvement, please [open an issue](https://github.com/agext/levenshtein/issues). Pull requests are welcome.
+
+## Overview
+
+The Levenshtein `Distance` between two strings is the minimum total cost of edits that would convert the first string into the second. The allowed edit operations are insertions, deletions, and substitutions, all at character (one UTF-8 code point) level. Each operation has a default cost of 1, but each can be assigned its own cost equal to or greater than 0.
+
+A `Distance` of 0 means the two strings are identical, and the higher the value the more different the strings. Since in practice we are interested in finding if the two strings are "close enough", it often does not make sense to continue the calculation once the result is mathematically guaranteed to exceed a desired threshold. Providing this value to the `Distance` function allows it to take a shortcut and return a lower bound instead of an exact cost when the threshold is exceeded.
+
+The `Similarity` function calculates the distance, then converts it into a normalized metric within the range 0..1, with 1 meaning the strings are identical, and 0 that they have nothing in common. A minimum similarity threshold can be provided to speed up the calculation of the metric for strings that are far too dissimilar for the purpose at hand. All values under this threshold are rounded down to 0.
+
+The `Match` function provides a similarity metric, with the same range and meaning as `Similarity`, but with a bonus for string pairs that share a common prefix and have a similarity above a "bonus threshold". It uses the same method as proposed by Winkler for the Jaro distance, and the reasoning behind it is that these string pairs are very likely spelling variations or errors, and they are more closely linked than the edit distance alone would suggest.
+
+The underlying `Calculate` function is also exported, to allow the building of other derivative metrics, if needed.
+
+## Installation
+
+```
+go get github.com/agext/levenshtein
+```
+
+## License
+
+Package levenshtein is released under the Apache 2.0 license. See the [LICENSE](LICENSE) file for details.
diff --git a/vendor/github.com/agext/levenshtein/levenshtein.go b/vendor/github.com/agext/levenshtein/levenshtein.go
new file mode 100644
index 000000000..df69ce701
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/levenshtein.go
@@ -0,0 +1,290 @@
+// Copyright 2016 ALRUX Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+/*
+Package levenshtein implements distance and similarity metrics for strings, based on the Levenshtein measure.
+
+The Levenshtein `Distance` between two strings is the minimum total cost of edits that would convert the first string into the second. The allowed edit operations are insertions, deletions, and substitutions, all at character (one UTF-8 code point) level. Each operation has a default cost of 1, but each can be assigned its own cost equal to or greater than 0.
+
+A `Distance` of 0 means the two strings are identical, and the higher the value the more different the strings. Since in practice we are interested in finding if the two strings are "close enough", it often does not make sense to continue the calculation once the result is mathematically guaranteed to exceed a desired threshold. Providing this value to the `Distance` function allows it to take a shortcut and return a lower bound instead of an exact cost when the threshold is exceeded.
+
+The `Similarity` function calculates the distance, then converts it into a normalized metric within the range 0..1, with 1 meaning the strings are identical, and 0 that they have nothing in common. A minimum similarity threshold can be provided to speed up the calculation of the metric for strings that are far too dissimilar for the purpose at hand. All values under this threshold are rounded down to 0.
+
+The `Match` function provides a similarity metric, with the same range and meaning as `Similarity`, but with a bonus for string pairs that share a common prefix and have a similarity above a "bonus threshold". It uses the same method as proposed by Winkler for the Jaro distance, and the reasoning behind it is that these string pairs are very likely spelling variations or errors, and they are more closely linked than the edit distance alone would suggest.
+
+The underlying `Calculate` function is also exported, to allow the building of other derivative metrics, if needed.
+*/
+package levenshtein
+
+// Calculate determines the Levenshtein distance between two strings, using
+// the given costs for each edit operation. It returns the distance along with
+// the lengths of the longest common prefix and suffix.
+//
+// If maxCost is non-zero, the calculation stops as soon as the distance is determined
+// to be greater than maxCost. Therefore, any return value higher than maxCost is a
+// lower bound for the actual distance.
+func Calculate(str1, str2 []rune, maxCost, insCost, subCost, delCost int) (dist, prefixLen, suffixLen int) {
+	l1, l2 := len(str1), len(str2)
+	// trim common prefix, if any, as it doesn't affect the distance
+	for ; prefixLen < l1 && prefixLen < l2; prefixLen++ {
+		if str1[prefixLen] != str2[prefixLen] {
+			break
+		}
+	}
+	str1, str2 = str1[prefixLen:], str2[prefixLen:]
+	l1 -= prefixLen
+	l2 -= prefixLen
+	// trim common suffix, if any, as it doesn't affect the distance
+	for 0 < l1 && 0 < l2 {
+		if str1[l1-1] != str2[l2-1] {
+			str1, str2 = str1[:l1], str2[:l2]
+			break
+		}
+		l1--
+		l2--
+		suffixLen++
+	}
+	// if the first string is empty, the distance is the length of the second string times the cost of insertion
+	if l1 == 0 {
+		dist = l2 * insCost
+		return
+	}
+	// if the second string is empty, the distance is the length of the first string times the cost of deletion
+	if l2 == 0 {
+		dist = l1 * delCost
+		return
+	}
+
+	// variables used in inner "for" loops
+	var y, dy, c, l int
+
+	// if maxCost is greater than or equal to the maximum possible distance, it's equivalent to 'unlimited'
+	if maxCost > 0 {
+		if subCost < delCost+insCost {
+			if maxCost >= l1*subCost+(l2-l1)*insCost {
+				maxCost = 0
+			}
+		} else {
+			if maxCost >= l1*delCost+l2*insCost {
+				maxCost = 0
+			}
+		}
+	}
+
+	if maxCost > 0 {
+		// prefer the longer string first, to minimize time;
+		// a swap also transposes the meanings of insertion and deletion.
+		if l1 < l2 {
+			str1, str2, l1, l2, insCost, delCost = str2, str1, l2, l1, delCost, insCost
+		}
+
+		// the length differential times cost of deletion is a lower bound for the cost;
+		// if it is higher than the maxCost, there is no point going into the main calculation.
+		if dist = (l1 - l2) * delCost; dist > maxCost {
+			return
+		}
+
+		d := make([]int, l1+1)
+
+		// offset and length of d in the current row
+		doff, dlen := 0, 1
+		for y, dy = 1, delCost; y <= l1 && dy <= maxCost; dlen++ {
+			d[y] = dy
+			y++
+			dy = y * delCost
+		}
+		// fmt.Printf("%q -> %q: init doff=%d dlen=%d d[%d:%d]=%v\n", str1, str2, doff, dlen, doff, doff+dlen, d[doff:doff+dlen])
+
+		for x := 0; x < l2; x++ {
+			dy, d[doff] = d[doff], d[doff]+insCost
+			for d[doff] > maxCost && dlen > 0 {
+				if str1[doff] != str2[x] {
+					dy += subCost
+				}
+				doff++
+				dlen--
+				if c = d[doff] + insCost; c < dy {
+					dy = c
+				}
+				dy, d[doff] = d[doff], dy
+			}
+			for y, l = doff, doff+dlen-1; y < l; dy, d[y] = d[y], dy {
+				if str1[y] != str2[x] {
+					dy += subCost
+				}
+				if c = d[y] + delCost; c < dy {
+					dy = c
+				}
+				y++
+				if c = d[y] + insCost; c < dy {
+					dy = c
+				}
+			}
+			if y < l1 {
+				if str1[y] != str2[x] {
+					dy += subCost
+				}
+				if c = d[y] + delCost; c < dy {
+					dy = c
+				}
+				for ; dy <= maxCost && y < l1; dy, d[y] = dy+delCost, dy {
+					y++
+					dlen++
+				}
+			}
+			// fmt.Printf("%q -> %q: x=%d doff=%d dlen=%d d[%d:%d]=%v\n", str1, str2, x, doff, dlen, doff, doff+dlen, d[doff:doff+dlen])
+			if dlen == 0 {
+				dist = maxCost + 1
+				return
+			}
+		}
+		if doff+dlen-1 < l1 {
+			dist = maxCost + 1
+			return
+		}
+		dist = d[l1]
+	} else {
+		// ToDo: This is O(l1*l2) time and O(min(l1,l2)) space; investigate if it is
+		// worth to implement diagonal approach - O(l1*(1+dist)) time, up to O(l1*l2) space
+		// http://www.csse.monash.edu.au/~lloyd/tildeStrings/Alignment/92.IPL.html
+
+		// prefer the shorter string first, to minimize space; time is O(l1*l2) anyway;
+		// a swap also transposes the meanings of insertion and deletion.
+		if l1 > l2 {
+			str1, str2, l1, l2, insCost, delCost = str2, str1, l2, l1, delCost, insCost
+		}
+		d := make([]int, l1+1)
+
+		for y = 1; y <= l1; y++ {
+			d[y] = y * delCost
+		}
+		for x := 0; x < l2; x++ {
+			dy, d[0] = d[0], d[0]+insCost
+			for y = 0; y < l1; dy, d[y] = d[y], dy {
+				if str1[y] != str2[x] {
+					dy += subCost
+				}
+				if c = d[y] + delCost; c < dy {
+					dy = c
+				}
+				y++
+				if c = d[y] + insCost; c < dy {
+					dy = c
+				}
+			}
+		}
+		dist = d[l1]
+	}
+
+	return
+}
+
+// Distance returns the Levenshtein distance between str1 and str2, using the
+// default or provided cost values. Pass nil for the third argument to use the
+// default cost of 1 for all three operations, with no maximum.
+func Distance(str1, str2 string, p *Params) int {
+	if p == nil {
+		p = defaultParams
+	}
+	dist, _, _ := Calculate([]rune(str1), []rune(str2), p.maxCost, p.insCost, p.subCost, p.delCost)
+	return dist
+}
+
+// Similarity returns a score in the range of 0..1 for how similar the two strings are.
+// A score of 1 means the strings are identical, and 0 means they have nothing in common.
+//
+// A nil third argument uses the default cost of 1 for all three operations.
+//
+// If a non-zero MinScore value is provided in the parameters, scores lower than it
+// will be returned as 0.
+func Similarity(str1, str2 string, p *Params) float64 {
+	return Match(str1, str2, p.Clone().BonusThreshold(1.1)) // guaranteed no bonus
+}
+
+// Match returns a similarity score adjusted by the same method as proposed by Winkler for
+// the Jaro distance - giving a bonus to string pairs that share a common prefix, only if their
+// similarity score is already over a threshold.
+//
+// The score is in the range of 0..1, with 1 meaning the strings are identical,
+// and 0 meaning they have nothing in common.
+//
+// A nil third argument uses the default cost of 1 for all three operations, maximum length of
+// common prefix to consider for bonus of 4, scaling factor of 0.1, and bonus threshold of 0.7.
+//
+// If a non-zero MinScore value is provided in the parameters, scores lower than it
+// will be returned as 0.
+func Match(str1, str2 string, p *Params) float64 {
+	s1, s2 := []rune(str1), []rune(str2)
+	l1, l2 := len(s1), len(s2)
+	// two empty strings are identical; shortcut also avoids divByZero issues later on.
+	if l1 == 0 && l2 == 0 {
+		return 1
+	}
+
+	if p == nil {
+		p = defaultParams
+	}
+
+	// a min over 1 can never be satisfied, so the score is 0.
+	if p.minScore > 1 {
+		return 0
+	}
+
+	insCost, delCost, maxDist, max := p.insCost, p.delCost, 0, 0
+	if l1 > l2 {
+		l1, l2, insCost, delCost = l2, l1, delCost, insCost
+	}
+
+	if p.subCost < delCost+insCost {
+		maxDist = l1*p.subCost + (l2-l1)*insCost
+	} else {
+		maxDist = l1*delCost + l2*insCost
+	}
+
+	// a zero min is always satisfied, so no need to set a max cost.
+	if p.minScore > 0 {
+		// if p.minScore is lower than p.bonusThreshold, we can use a simplified formula
+		// for the max cost, because a sim score below min cannot receive a bonus.
+		if p.minScore < p.bonusThreshold {
+			// round down the max - a cost equal to a rounded up max would already be under min.
+			max = int((1 - p.minScore) * float64(maxDist))
+		} else {
+			// p.minScore <= sim + p.bonusPrefix*p.bonusScale*(1-sim)
+			// p.minScore <= (1-dist/maxDist) + p.bonusPrefix*p.bonusScale*(1-(1-dist/maxDist))
+			// p.minScore <= 1 - dist/maxDist + p.bonusPrefix*p.bonusScale*dist/maxDist
+			// 1 - p.minScore >= dist/maxDist - p.bonusPrefix*p.bonusScale*dist/maxDist
+			// (1-p.minScore)*maxDist/(1-p.bonusPrefix*p.bonusScale) >= dist
+			max = int((1 - p.minScore) * float64(maxDist) / (1 - float64(p.bonusPrefix)*p.bonusScale))
+		}
+	}
+
+	dist, pl, _ := Calculate(s1, s2, max, p.insCost, p.subCost, p.delCost)
+	if max > 0 && dist > max {
+		return 0
+	}
+	sim := 1 - float64(dist)/float64(maxDist)
+
+	if sim >= p.bonusThreshold && sim < 1 && p.bonusPrefix > 0 && p.bonusScale > 0 {
+		if pl > p.bonusPrefix {
+			pl = p.bonusPrefix
+		}
+		sim += float64(pl) * p.bonusScale * (1 - sim)
+	}
+
+	if sim < p.minScore {
+		return 0
+	}
+
+	return sim
+}
diff --git a/vendor/github.com/agext/levenshtein/params.go b/vendor/github.com/agext/levenshtein/params.go
new file mode 100644
index 000000000..a85727b3e
--- /dev/null
+++ b/vendor/github.com/agext/levenshtein/params.go
@@ -0,0 +1,152 @@
+// Copyright 2016 ALRUX Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//    http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package levenshtein
+
+// Params represents a set of parameter values for the various formulas involved
+// in the calculation of the Levenshtein string metrics.
+type Params struct {
+	insCost        int
+	subCost        int
+	delCost        int
+	maxCost        int
+	minScore       float64
+	bonusPrefix    int
+	bonusScale     float64
+	bonusThreshold float64
+}
+
+var (
+	defaultParams = NewParams()
+)
+
+// NewParams creates a new set of parameters and initializes it with the default values.
+func NewParams() *Params {
+	return &Params{
+		insCost:        1,
+		subCost:        1,
+		delCost:        1,
+		maxCost:        0,
+		minScore:       0,
+		bonusPrefix:    4,
+		bonusScale:     .1,
+		bonusThreshold: .7,
+	}
+}
+
+// Clone returns a pointer to a copy of the receiver parameter set, or of a new
+// default parameter set if the receiver is nil.
+func (p *Params) Clone() *Params {
+	if p == nil {
+		return NewParams()
+	}
+	return &Params{
+		insCost:        p.insCost,
+		subCost:        p.subCost,
+		delCost:        p.delCost,
+		maxCost:        p.maxCost,
+		minScore:       p.minScore,
+		bonusPrefix:    p.bonusPrefix,
+		bonusScale:     p.bonusScale,
+		bonusThreshold: p.bonusThreshold,
+	}
+}
+
+// InsCost overrides the default value of 1 for the cost of insertion.
+// The new value must be zero or positive.
+func (p *Params) InsCost(v int) *Params {
+	if v >= 0 {
+		p.insCost = v
+	}
+	return p
+}
+
+// SubCost overrides the default value of 1 for the cost of substitution.
+// The new value must be zero or positive.
+func (p *Params) SubCost(v int) *Params {
+	if v >= 0 {
+		p.subCost = v
+	}
+	return p
+}
+
+// DelCost overrides the default value of 1 for the cost of deletion.
+// The new value must be zero or positive.
+func (p *Params) DelCost(v int) *Params {
+	if v >= 0 {
+		p.delCost = v
+	}
+	return p
+}
+
+// MaxCost overrides the default value of 0 (meaning unlimited) for the maximum cost.
+// The calculation of Distance() stops when the result is guaranteed to exceed
+// this maximum, returning a lower-bound rather than exact value.
+// The new value must be zero or positive.
+func (p *Params) MaxCost(v int) *Params {
+	if v >= 0 {
+		p.maxCost = v
+	}
+	return p
+}
+
+// MinScore overrides the default value of 0 for the minimum similarity score.
+// Scores below this threshold are returned as 0 by Similarity() and Match().
+// The new value must be zero or positive. Note that a minimum greater than 1
+// can never be satisfied, resulting in a score of 0 for any pair of strings.
+func (p *Params) MinScore(v float64) *Params {
+	if v >= 0 {
+		p.minScore = v
+	}
+	return p
+}
+
+// BonusPrefix overrides the default value for the maximum length of
+// common prefix to be considered for bonus by Match().
+// The new value must be zero or positive.
+func (p *Params) BonusPrefix(v int) *Params {
+	if v >= 0 {
+		p.bonusPrefix = v
+	}
+	return p
+}
+
+// BonusScale overrides the default value for the scaling factor used by Match()
+// in calculating the bonus.
+// The new value must be zero or positive. To guarantee that the similarity score
+// remains in the interval 0..1, this scaling factor is not allowed to exceed
+// 1 / BonusPrefix.
+func (p *Params) BonusScale(v float64) *Params {
+	if v >= 0 {
+		p.bonusScale = v
+	}
+
+	// the bonus cannot exceed (1-sim), or the score may become greater than 1.
+	if float64(p.bonusPrefix)*p.bonusScale > 1 {
+		p.bonusScale = 1 / float64(p.bonusPrefix)
+	}
+
+	return p
+}
+
+// BonusThreshold overrides the default value for the minimum similarity score
+// for which Match() can assign a bonus.
+// The new value must be zero or positive. Note that a threshold greater than 1
+// effectively makes Match() become the equivalent of Similarity().
+func (p *Params) BonusThreshold(v float64) *Params {
+	if v >= 0 {
+		p.bonusThreshold = v
+	}
+	return p
+}
diff --git a/vendor/github.com/apparentlymart/go-textseg/LICENSE b/vendor/github.com/apparentlymart/go-textseg/LICENSE
new file mode 100644
index 000000000..684b03b4a
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/LICENSE
@@ -0,0 +1,95 @@
+Copyright (c) 2017 Martin Atkins
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
+
+---------
+
+Unicode table generation programs are under a separate copyright and license:
+
+Copyright (c) 2014 Couchbase, Inc.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file
+except in compliance with the License. You may obtain a copy of the License at
+
+    http://www.apache.org/licenses/LICENSE-2.0
+
+Unless required by applicable law or agreed to in writing, software distributed under the
+License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND,
+either express or implied. See the License for the specific language governing permissions
+and limitations under the License.
+
+---------
+
+Grapheme break data is provided as part of the Unicode character database,
+copright 2016 Unicode, Inc, which is provided with the following license:
+
+Unicode Data Files include all data files under the directories
+http://www.unicode.org/Public/, http://www.unicode.org/reports/,
+http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, and
+http://www.unicode.org/utility/trac/browser/.
+
+Unicode Data Files do not include PDF online code charts under the
+directory http://www.unicode.org/Public/.
+
+Software includes any source code published in the Unicode Standard
+or under the directories
+http://www.unicode.org/Public/, http://www.unicode.org/reports/,
+http://www.unicode.org/cldr/data/, http://source.icu-project.org/repos/icu/, and
+http://www.unicode.org/utility/trac/browser/.
+
+NOTICE TO USER: Carefully read the following legal agreement.
+BY DOWNLOADING, INSTALLING, COPYING OR OTHERWISE USING UNICODE INC.'S
+DATA FILES ("DATA FILES"), AND/OR SOFTWARE ("SOFTWARE"),
+YOU UNEQUIVOCALLY ACCEPT, AND AGREE TO BE BOUND BY, ALL OF THE
+TERMS AND CONDITIONS OF THIS AGREEMENT.
+IF YOU DO NOT AGREE, DO NOT DOWNLOAD, INSTALL, COPY, DISTRIBUTE OR USE
+THE DATA FILES OR SOFTWARE.
+
+COPYRIGHT AND PERMISSION NOTICE
+
+Copyright © 1991-2017 Unicode, Inc. All rights reserved.
+Distributed under the Terms of Use in http://www.unicode.org/copyright.html.
+
+Permission is hereby granted, free of charge, to any person obtaining
+a copy of the Unicode data files and any associated documentation
+(the "Data Files") or Unicode software and any associated documentation
+(the "Software") to deal in the Data Files or Software
+without restriction, including without limitation the rights to use,
+copy, modify, merge, publish, distribute, and/or sell copies of
+the Data Files or Software, and to permit persons to whom the Data Files
+or Software are furnished to do so, provided that either
+(a) this copyright and permission notice appear with all copies
+of the Data Files or Software, or
+(b) this copyright and permission notice appear in associated
+Documentation.
+
+THE DATA FILES AND SOFTWARE ARE PROVIDED "AS IS", WITHOUT WARRANTY OF
+ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE
+WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
+NONINFRINGEMENT OF THIRD PARTY RIGHTS.
+IN NO EVENT SHALL THE COPYRIGHT HOLDER OR HOLDERS INCLUDED IN THIS
+NOTICE BE LIABLE FOR ANY CLAIM, OR ANY SPECIAL INDIRECT OR CONSEQUENTIAL
+DAMAGES, OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS OF USE,
+DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
+TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THE DATA FILES OR SOFTWARE.
+
+Except as contained in this notice, the name of a copyright holder
+shall not be used in advertising or otherwise to promote the sale,
+use or other dealings in these Data Files or Software without prior
+written authorization of the copyright holder.
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/all_tokens.go b/vendor/github.com/apparentlymart/go-textseg/textseg/all_tokens.go
new file mode 100644
index 000000000..5752e9ef8
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/all_tokens.go
@@ -0,0 +1,30 @@
+package textseg
+
+import (
+	"bufio"
+	"bytes"
+)
+
+// AllTokens is a utility that uses a bufio.SplitFunc to produce a slice of
+// all of the recognized tokens in the given buffer.
+func AllTokens(buf []byte, splitFunc bufio.SplitFunc) ([][]byte, error) {
+	scanner := bufio.NewScanner(bytes.NewReader(buf))
+	scanner.Split(splitFunc)
+	var ret [][]byte
+	for scanner.Scan() {
+		ret = append(ret, scanner.Bytes())
+	}
+	return ret, scanner.Err()
+}
+
+// TokenCount is a utility that uses a bufio.SplitFunc to count the number of
+// recognized tokens in the given buffer.
+func TokenCount(buf []byte, splitFunc bufio.SplitFunc) (int, error) {
+	scanner := bufio.NewScanner(bytes.NewReader(buf))
+	scanner.Split(splitFunc)
+	var ret int
+	for scanner.Scan() {
+		ret++
+	}
+	return ret, scanner.Err()
+}
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/generate.go b/vendor/github.com/apparentlymart/go-textseg/textseg/generate.go
new file mode 100644
index 000000000..81f3a7471
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/generate.go
@@ -0,0 +1,7 @@
+package textseg
+
+//go:generate go run make_tables.go -output tables.go
+//go:generate go run make_test_tables.go -output tables_test.go
+//go:generate ruby unicode2ragel.rb --url=http://www.unicode.org/Public/9.0.0/ucd/auxiliary/GraphemeBreakProperty.txt -m GraphemeCluster -p "Prepend,CR,LF,Control,Extend,Regional_Indicator,SpacingMark,L,V,T,LV,LVT,E_Base,E_Modifier,ZWJ,Glue_After_Zwj,E_Base_GAZ" -o grapheme_clusters_table.rl
+//go:generate ragel -Z grapheme_clusters.rl
+//go:generate gofmt -w grapheme_clusters.go
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.go b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.go
new file mode 100644
index 000000000..012bc690a
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.go
@@ -0,0 +1,5276 @@
+
+// line 1 "grapheme_clusters.rl"
+package textseg
+
+import (
+    "errors"
+    "unicode/utf8"
+)
+
+// Generated from grapheme_clusters.rl. DO NOT EDIT
+
+// line 13 "grapheme_clusters.go"
+var _graphclust_actions []byte = []byte{
+	0, 1, 0, 1, 4, 1, 9, 1, 10, 
+	1, 11, 1, 12, 1, 13, 1, 14, 
+	1, 15, 1, 16, 1, 17, 1, 18, 
+	1, 19, 1, 20, 1, 21, 2, 1, 
+	7, 2, 1, 8, 2, 2, 3, 2, 
+	5, 1, 3, 0, 1, 8, 3, 5, 
+	0, 1, 3, 5, 1, 6, 
+}
+
+var _graphclust_key_offsets []int16 = []int16{
+	0, 0, 1, 3, 5, 7, 10, 15, 
+	17, 20, 28, 31, 33, 35, 37, 67, 
+	75, 77, 81, 84, 89, 94, 104, 116, 
+	122, 127, 137, 140, 147, 151, 159, 169, 
+	173, 181, 183, 191, 194, 196, 201, 203, 
+	210, 212, 220, 221, 242, 246, 252, 257, 
+	259, 263, 267, 269, 273, 275, 278, 282, 
+	284, 291, 293, 297, 301, 305, 307, 309, 
+	318, 322, 327, 329, 335, 337, 338, 340, 
+	341, 343, 345, 347, 349, 364, 368, 370, 
+	372, 377, 381, 385, 387, 389, 393, 397, 
+	399, 403, 410, 415, 419, 422, 423, 427, 
+	434, 439, 440, 441, 443, 452, 454, 477, 
+	481, 483, 487, 491, 492, 496, 500, 503, 
+	505, 510, 523, 525, 527, 529, 531, 535, 
+	539, 541, 543, 545, 549, 553, 557, 559, 
+	561, 563, 565, 566, 568, 574, 580, 586, 
+	588, 592, 596, 601, 604, 614, 616, 618, 
+	621, 623, 625, 627, 629, 632, 637, 639, 
+	642, 650, 653, 655, 657, 659, 690, 698, 
+	700, 704, 711, 723, 730, 744, 750, 768, 
+	779, 785, 797, 800, 809, 814, 824, 830, 
+	844, 850, 862, 874, 878, 880, 886, 888, 
+	895, 898, 906, 907, 928, 937, 945, 951, 
+	953, 957, 961, 966, 972, 974, 977, 990, 
+	995, 1009, 1011, 1020, 1027, 1038, 1048, 1056, 
+	1067, 1071, 1076, 1078, 1080, 1082, 1083, 1085, 
+	1087, 1089, 1091, 1106, 1110, 1112, 1114, 1122, 
+	1130, 1132, 1136, 1147, 1150, 1160, 1164, 1171, 
+	1179, 1185, 1188, 1189, 1193, 1200, 1205, 1206, 
+	1207, 1209, 1218, 1220, 1243, 1248, 1250, 1259, 
+	1264, 1265, 1274, 1280, 1290, 1295, 1302, 1316, 
+	1320, 1325, 1336, 1339, 1349, 1353, 1362, 1364, 
+	1372, 1379, 1385, 1392, 1396, 1398, 1400, 1402, 
+	1403, 1405, 1411, 1419, 1425, 1427, 1431, 1435, 
+	1440, 1443, 1453, 1455, 1457, 1458, 1460, 1461, 
+	1467, 1469, 1471, 1471, 1472, 1473, 1474, 1480, 
+	1482, 1484, 1484, 1490, 1492, 1497, 1502, 1504, 
+	1506, 1508, 1511, 1516, 1518, 1521, 1529, 1532, 
+	1534, 1536, 1538, 1568, 1576, 1578, 1582, 1585, 
+	1590, 1595, 1605, 1617, 1623, 1628, 1638, 1641, 
+	1648, 1652, 1660, 1670, 1674, 1682, 1684, 1692, 
+	1695, 1697, 1702, 1704, 1711, 1713, 1721, 1722, 
+	1743, 1747, 1753, 1758, 1760, 1764, 1768, 1770, 
+	1774, 1776, 1779, 1783, 1785, 1792, 1794, 1798, 
+	1802, 1806, 1808, 1810, 1819, 1823, 1828, 1830, 
+	1836, 1838, 1839, 1841, 1842, 1844, 1846, 1848, 
+	1850, 1865, 1869, 1871, 1873, 1878, 1882, 1886, 
+	1888, 1890, 1894, 1898, 1900, 1904, 1911, 1916, 
+	1920, 1923, 1924, 1928, 1935, 1940, 1941, 1942, 
+	1944, 1953, 1955, 1978, 1982, 1984, 1988, 1992, 
+	1993, 1997, 2001, 2004, 2006, 2011, 2024, 2026, 
+	2028, 2030, 2032, 2036, 2040, 2042, 2044, 2046, 
+	2050, 2054, 2058, 2060, 2062, 2064, 2066, 2067, 
+	2069, 2075, 2081, 2087, 2089, 2093, 2097, 2102, 
+	2105, 2115, 2117, 2119, 2122, 2124, 2126, 2128, 
+	2130, 2133, 2138, 2140, 2143, 2151, 2154, 2156, 
+	2158, 2160, 2191, 2199, 2201, 2205, 2212, 2224, 
+	2231, 2245, 2251, 2269, 2280, 2286, 2298, 2301, 
+	2310, 2315, 2325, 2331, 2345, 2351, 2363, 2375, 
+	2379, 2381, 2387, 2389, 2396, 2399, 2407, 2408, 
+	2429, 2438, 2446, 2452, 2454, 2458, 2462, 2467, 
+	2473, 2475, 2478, 2491, 2496, 2510, 2512, 2521, 
+	2528, 2539, 2549, 2557, 2568, 2572, 2577, 2579, 
+	2581, 2583, 2584, 2586, 2588, 2590, 2592, 2607, 
+	2611, 2613, 2615, 2623, 2631, 2633, 2637, 2648, 
+	2651, 2661, 2665, 2672, 2680, 2686, 2689, 2690, 
+	2694, 2701, 2706, 2707, 2708, 2710, 2719, 2721, 
+	2744, 2749, 2751, 2760, 2765, 2766, 2775, 2781, 
+	2791, 2796, 2803, 2817, 2821, 2826, 2837, 2840, 
+	2850, 2854, 2863, 2865, 2873, 2880, 2886, 2893, 
+	2897, 2899, 2901, 2903, 2904, 2906, 2912, 2920, 
+	2926, 2928, 2932, 2936, 2941, 2944, 2954, 2956, 
+	2958, 2959, 2961, 2962, 2968, 2970, 2972, 2972, 
+	2973, 2974, 2975, 2981, 2983, 2985, 2985, 2991, 
+	2993, 2997, 3003, 3006, 3009, 3013, 3016, 3019, 
+	3026, 3028, 3052, 3054, 3078, 3080, 3082, 3105, 
+	3107, 3109, 3110, 3112, 3114, 3116, 3122, 3124, 
+	3156, 3160, 3165, 3188, 3190, 3192, 3194, 3196, 
+	3199, 3201, 3203, 3207, 3207, 3263, 3319, 3350, 
+	3355, 3359, 3366, 3374, 3378, 3381, 3384, 3390, 
+	3392, 3412, 3418, 3423, 3425, 3427, 3430, 3432, 
+	3434, 3438, 3494, 3550, 3581, 3586, 3594, 3598, 
+	3600, 3605, 3611, 3615, 3618, 3624, 3627, 3631, 
+	3634, 3638, 3651, 3655, 3662, 3663, 3665, 3668, 
+	3678, 3698, 3705, 3709, 3716, 3726, 3733, 3736, 
+	3751, 3753, 3756, 3761, 3763, 3766, 3769, 3773, 
+	3776, 3779, 3786, 3788, 3790, 3792, 3794, 3797, 
+	3802, 3804, 3807, 3815, 3818, 3820, 3822, 3824, 
+	3854, 3862, 3864, 3868, 3871, 3876, 3881, 3891, 
+	3903, 3909, 3914, 3924, 3927, 3934, 3938, 3946, 
+	3956, 3960, 3968, 3970, 3978, 3981, 3983, 3988, 
+	3990, 3997, 3999, 4007, 4008, 4029, 4033, 4039, 
+	4044, 4046, 4050, 4054, 4056, 4060, 4062, 4065, 
+	4069, 4071, 4078, 4080, 4084, 4088, 4092, 4094, 
+	4096, 4105, 4109, 4114, 4116, 4122, 4124, 4125, 
+	4127, 4128, 4130, 4132, 4134, 4136, 4151, 4155, 
+	4157, 4159, 4164, 4168, 4172, 4174, 4176, 4180, 
+	4184, 4186, 4190, 4197, 4202, 4206, 4209, 4210, 
+	4214, 4221, 4226, 4227, 4228, 4230, 4239, 4241, 
+	4264, 4268, 4270, 4274, 4278, 4279, 4283, 4287, 
+	4290, 4292, 4297, 4310, 4312, 4314, 4316, 4318, 
+	4322, 4326, 4328, 4330, 4332, 4336, 4340, 4344, 
+	4346, 4348, 4350, 4352, 4353, 4355, 4361, 4367, 
+	4373, 4375, 4379, 4383, 4388, 4391, 4401, 4403, 
+	4405, 4408, 4410, 4412, 4414, 4416, 4419, 4424, 
+	4426, 4429, 4437, 4440, 4442, 4444, 4446, 4477, 
+	4485, 4487, 4491, 4498, 4510, 4517, 4531, 4537, 
+	4555, 4566, 4572, 4584, 4587, 4596, 4601, 4611, 
+	4617, 4631, 4637, 4649, 4661, 4665, 4667, 4673, 
+	4675, 4682, 4685, 4693, 4694, 4715, 4724, 4732, 
+	4738, 4740, 4744, 4748, 4753, 4759, 4761, 4764, 
+	4777, 4782, 4796, 4798, 4807, 4814, 4825, 4835, 
+	4843, 4854, 4858, 4863, 4865, 4867, 4869, 4870, 
+	4872, 4874, 4876, 4878, 4893, 4897, 4899, 4901, 
+	4909, 4917, 4919, 4923, 4934, 4937, 4947, 4951, 
+	4958, 4966, 4972, 4975, 4976, 4980, 4987, 4992, 
+	4993, 4994, 4996, 5005, 5007, 5030, 5035, 5037, 
+	5046, 5051, 5052, 5061, 5067, 5077, 5082, 5089, 
+	5103, 5107, 5112, 5123, 5126, 5136, 5140, 5149, 
+	5151, 5159, 5166, 5172, 5179, 5183, 5185, 5187, 
+	5189, 5190, 5192, 5198, 5206, 5212, 5214, 5218, 
+	5222, 5227, 5230, 5240, 5242, 5244, 5245, 5247, 
+	5248, 5254, 5256, 5258, 5258, 5259, 5260, 5261, 
+	5267, 5269, 5271, 5271, 5277, 5301, 5303, 5327, 
+	5329, 5331, 5354, 5356, 5358, 5359, 5361, 5363, 
+	5365, 5371, 5373, 5405, 5409, 5414, 5437, 5439, 
+	5441, 5443, 5445, 5448, 5450, 5452, 5456, 5456, 
+	5512, 5568, 5599, 5604, 5607, 5614, 5626, 5628, 
+	5630, 5632, 5635, 5640, 5642, 5645, 5653, 5656, 
+	5658, 5660, 5662, 5692, 5700, 5702, 5706, 5709, 
+	5714, 5719, 5729, 5741, 5747, 5752, 5762, 5765, 
+	5772, 5776, 5784, 5794, 5798, 5806, 5808, 5816, 
+	5819, 5821, 5826, 5828, 5835, 5837, 5845, 5846, 
+	5867, 5871, 5877, 5882, 5884, 5888, 5892, 5894, 
+	5898, 5900, 5903, 5907, 5909, 5916, 5918, 5922, 
+	5926, 5930, 5932, 5934, 5943, 5947, 5952, 5954, 
+	5956, 5958, 5959, 5961, 5963, 5965, 5967, 5982, 
+	5986, 5988, 5990, 5995, 5999, 6003, 6005, 6007, 
+	6011, 6015, 6017, 6021, 6028, 6033, 6037, 6040, 
+	6041, 6045, 6051, 6056, 6057, 6058, 6060, 6069, 
+	6071, 6094, 6098, 6100, 6104, 6108, 6109, 6113, 
+	6117, 6120, 6122, 6127, 6140, 6142, 6144, 6146, 
+	6148, 6152, 6156, 6158, 6160, 6162, 6166, 6170, 
+	6174, 6176, 6178, 6180, 6182, 6183, 6185, 6191, 
+	6197, 6203, 6205, 6209, 6213, 6218, 6221, 6231, 
+	6233, 6235, 6236, 6242, 6244, 6246, 6246, 6252, 
+	6253, 6260, 6263, 6265, 6267, 6269, 6271, 6274, 
+	6279, 6281, 6284, 6292, 6295, 6297, 6299, 6301, 
+	6332, 6340, 6342, 6346, 6353, 6365, 6372, 6386, 
+	6392, 6410, 6421, 6427, 6439, 6442, 6451, 6456, 
+	6466, 6472, 6486, 6492, 6504, 6516, 6520, 6522, 
+	6528, 6530, 6537, 6540, 6548, 6549, 6570, 6579, 
+	6587, 6593, 6595, 6599, 6603, 6608, 6614, 6616, 
+	6619, 6632, 6637, 6651, 6653, 6662, 6669, 6680, 
+	6690, 6698, 6709, 6713, 6718, 6720, 6722, 6724, 
+	6725, 6727, 6729, 6731, 6733, 6748, 6752, 6754, 
+	6756, 6764, 6772, 6774, 6778, 6789, 6792, 6802, 
+	6806, 6813, 6821, 6827, 6830, 6831, 6835, 6842, 
+	6847, 6848, 6849, 6851, 6860, 6862, 6885, 6890, 
+	6892, 6901, 6906, 6907, 6916, 6922, 6932, 6937, 
+	6944, 6958, 6962, 6967, 6978, 6981, 6991, 6995, 
+	7004, 7006, 7014, 7021, 7027, 7034, 7038, 7040, 
+	7042, 7044, 7045, 7047, 7053, 7061, 7067, 7069, 
+	7073, 7077, 7082, 7085, 7095, 7097, 7099, 7100, 
+	7102, 7103, 7109, 7111, 7113, 7113, 7114, 7115, 
+	7121, 7124, 7126, 7128, 7130, 7133, 7138, 7140, 
+	7143, 7151, 7154, 7156, 7158, 7160, 7191, 7199, 
+	7201, 7205, 7212, 7214, 7216, 7218, 7221, 7226, 
+	7228, 7231, 7239, 7242, 7244, 7246, 7248, 7278, 
+	7286, 7288, 7292, 7295, 7300, 7305, 7315, 7327, 
+	7333, 7338, 7348, 7351, 7358, 7362, 7370, 7380, 
+	7384, 7392, 7394, 7402, 7405, 7407, 7412, 7414, 
+	7421, 7423, 7431, 7432, 7453, 7457, 7463, 7468, 
+	7470, 7474, 7478, 7480, 7484, 7486, 7489, 7493, 
+	7495, 7502, 7504, 7508, 7512, 7516, 7518, 7520, 
+	7529, 7533, 7538, 7540, 7546, 7548, 7549, 7551, 
+	7552, 7554, 7556, 7558, 7560, 7575, 7579, 7581, 
+	7583, 7588, 7592, 7596, 7598, 7600, 7604, 7608, 
+	7610, 7614, 7621, 7626, 7630, 7633, 7634, 7638, 
+	7645, 7650, 7651, 7652, 7654, 7663, 7665, 7688, 
+	7692, 7694, 7698, 7702, 7703, 7707, 7711, 7714, 
+	7716, 7721, 7734, 7736, 7738, 7740, 7742, 7746, 
+	7750, 7752, 7754, 7756, 7760, 7764, 7768, 7770, 
+	7772, 7774, 7776, 7777, 7779, 7785, 7791, 7797, 
+	7799, 7803, 7807, 7812, 7815, 7825, 7827, 7829, 
+	7832, 7834, 7835, 7836, 7837, 7843, 7845, 7847, 
+	7847, 7853, 7865, 7872, 7886, 7892, 7910, 7921, 
+	7927, 7939, 7942, 7951, 7956, 7966, 7972, 7986, 
+	7992, 8004, 8016, 8020, 8022, 8028, 8030, 8037, 
+	8040, 8048, 8049, 8070, 8079, 8087, 8093, 8095, 
+	8099, 8103, 8108, 8114, 8116, 8119, 8132, 8137, 
+	8151, 8153, 8162, 8169, 8180, 8190, 8198, 8209, 
+	8213, 8218, 8220, 8222, 8224, 8225, 8227, 8229, 
+	8231, 8233, 8248, 8252, 8254, 8256, 8264, 8272, 
+	8274, 8278, 8289, 8292, 8302, 8306, 8313, 8321, 
+	8327, 8330, 8331, 8335, 8342, 8347, 8348, 8349, 
+	8351, 8360, 8362, 8385, 8390, 8392, 8401, 8406, 
+	8407, 8416, 8422, 8432, 8437, 8444, 8458, 8462, 
+	8467, 8478, 8481, 8491, 8495, 8504, 8506, 8514, 
+	8521, 8527, 8534, 8538, 8540, 8542, 8544, 8545, 
+	8547, 8553, 8561, 8567, 8569, 8573, 8577, 8582, 
+	8585, 8595, 8597, 8599, 8600, 8602, 8603, 8609, 
+	8611, 8613, 8613, 8616, 8622, 8624, 8644, 8650, 
+	8655, 8657, 8659, 8662, 8664, 8666, 8670, 8726, 
+	8782, 8817, 8822, 8830, 8832, 8832, 8834, 8838, 
+	8841, 8848, 8854, 8858, 8861, 8867, 8870, 8876, 
+	8879, 8885, 8898, 8902, 8904, 8906, 8908, 8911, 
+	8916, 8918, 8921, 8929, 8932, 8934, 8936, 8938, 
+	8968, 8976, 8978, 8982, 8985, 8990, 8995, 9005, 
+	9017, 9023, 9028, 9038, 9041, 9048, 9052, 9060, 
+	9070, 9074, 9082, 9084, 9092, 9095, 9097, 9102, 
+	9104, 9111, 9113, 9121, 9122, 9143, 9147, 9153, 
+	9158, 9160, 9164, 9168, 9170, 9174, 9176, 9179, 
+	9183, 9185, 9192, 9194, 9198, 9202, 9206, 9208, 
+	9210, 9219, 9223, 9228, 9230, 9236, 9238, 9239, 
+	9241, 9242, 9244, 9246, 9248, 9250, 9265, 9269, 
+	9271, 9273, 9278, 9282, 9286, 9288, 9290, 9294, 
+	9298, 9300, 9304, 9311, 9316, 9320, 9323, 9324, 
+	9328, 9335, 9340, 9341, 9342, 9344, 9353, 9355, 
+	9378, 9382, 9384, 9388, 9392, 9393, 9397, 9401, 
+	9404, 9406, 9411, 9424, 9426, 9428, 9430, 9432, 
+	9436, 9440, 9442, 9444, 9446, 9450, 9454, 9458, 
+	9460, 9462, 9464, 9466, 9467, 9469, 9475, 9481, 
+	9487, 9489, 9493, 9497, 9502, 9505, 9515, 9517, 
+	9519, 9522, 9524, 9526, 9528, 9530, 9533, 9538, 
+	9540, 9543, 9551, 9554, 9556, 9558, 9560, 9591, 
+	9599, 9601, 9605, 9612, 9624, 9631, 9645, 9651, 
+	9669, 9680, 9686, 9698, 9701, 9710, 9715, 9725, 
+	9731, 9745, 9751, 9763, 9775, 9779, 9781, 9787, 
+	9789, 9796, 9799, 9807, 9808, 9829, 9838, 9846, 
+	9852, 9854, 9858, 9862, 9867, 9873, 9875, 9878, 
+	9891, 9896, 9910, 9912, 9921, 9928, 9939, 9949, 
+	9957, 9968, 9972, 9977, 9979, 9981, 9983, 9984, 
+	9986, 9988, 9990, 9992, 10007, 10011, 10013, 10015, 
+	10023, 10031, 10033, 10037, 10048, 10051, 10061, 10065, 
+	10072, 10080, 10086, 10089, 10090, 10094, 10101, 10106, 
+	10107, 10108, 10110, 10119, 10121, 10144, 10149, 10151, 
+	10160, 10165, 10166, 10175, 10181, 10191, 10196, 10203, 
+	10217, 10221, 10226, 10237, 10240, 10250, 10254, 10263, 
+	10265, 10273, 10280, 10286, 10293, 10297, 10299, 10301, 
+	10303, 10304, 10306, 10312, 10320, 10326, 10328, 10332, 
+	10336, 10341, 10344, 10354, 10356, 10358, 10359, 10361, 
+	10362, 10368, 10370, 10372, 10372, 10373, 10374, 10375, 
+	10381, 10383, 10385, 10385, 10391, 10398, 10399, 10401, 
+	10404, 10414, 10434, 10441, 10445, 10452, 10462, 10469, 
+	10472, 10487, 10489, 10492, 10501, 10505, 10509, 10538, 
+	10558, 10578, 10598, 10620, 10640, 10660, 10680, 10703, 
+	10724, 10745, 10766, 10786, 10809, 10829, 10849, 10869, 
+	10890, 10911, 10932, 10952, 10972, 10992, 11012, 11032, 
+	11052, 11072, 11092, 11112, 
+}
+
+var _graphclust_trans_keys []byte = []byte{
+	10, 128, 255, 176, 255, 131, 137, 191, 
+	145, 189, 135, 129, 130, 132, 133, 144, 
+	154, 176, 139, 159, 150, 156, 159, 164, 
+	167, 168, 170, 173, 145, 176, 255, 139, 
+	255, 166, 176, 171, 179, 160, 161, 163, 
+	164, 165, 167, 169, 171, 173, 174, 175, 
+	176, 177, 179, 180, 181, 182, 183, 184, 
+	185, 186, 187, 188, 189, 190, 191, 166, 
+	170, 172, 178, 150, 153, 155, 163, 165, 
+	167, 169, 173, 153, 155, 148, 161, 163, 
+	255, 189, 132, 185, 144, 152, 161, 164, 
+	255, 188, 129, 131, 190, 255, 133, 134, 
+	137, 138, 142, 150, 152, 161, 164, 255, 
+	131, 134, 137, 138, 142, 144, 146, 175, 
+	178, 180, 182, 255, 134, 138, 142, 161, 
+	164, 255, 188, 129, 131, 190, 191, 128, 
+	132, 135, 136, 139, 141, 150, 151, 162, 
+	163, 130, 190, 191, 151, 128, 130, 134, 
+	136, 138, 141, 128, 131, 190, 255, 133, 
+	137, 142, 148, 151, 161, 164, 255, 128, 
+	132, 134, 136, 138, 141, 149, 150, 162, 
+	163, 129, 131, 190, 255, 133, 137, 142, 
+	150, 152, 161, 164, 255, 130, 131, 138, 
+	150, 143, 148, 152, 159, 178, 179, 177, 
+	179, 186, 135, 142, 177, 179, 185, 187, 
+	188, 136, 141, 181, 183, 185, 152, 153, 
+	190, 191, 177, 191, 128, 132, 134, 135, 
+	141, 151, 153, 188, 134, 128, 129, 130, 
+	141, 156, 157, 158, 159, 160, 162, 164, 
+	168, 169, 170, 172, 173, 174, 175, 176, 
+	179, 183, 173, 183, 185, 190, 150, 153, 
+	158, 160, 177, 180, 130, 141, 157, 132, 
+	134, 157, 159, 146, 148, 178, 180, 146, 
+	147, 178, 179, 180, 255, 148, 156, 158, 
+	255, 139, 141, 169, 133, 134, 160, 171, 
+	176, 187, 151, 155, 160, 162, 191, 149, 
+	158, 165, 188, 176, 190, 128, 132, 180, 
+	255, 133, 170, 180, 255, 128, 130, 161, 
+	173, 166, 179, 164, 183, 173, 144, 146, 
+	148, 168, 178, 180, 184, 185, 128, 181, 
+	187, 191, 128, 131, 179, 181, 183, 140, 
+	141, 128, 131, 157, 179, 181, 183, 144, 
+	176, 164, 175, 177, 191, 160, 191, 128, 
+	130, 170, 175, 153, 154, 153, 154, 155, 
+	160, 162, 163, 164, 165, 166, 167, 168, 
+	169, 170, 171, 175, 175, 178, 180, 189, 
+	158, 159, 176, 177, 130, 134, 139, 163, 
+	167, 128, 129, 180, 255, 134, 159, 178, 
+	255, 166, 173, 135, 147, 128, 131, 179, 
+	255, 129, 164, 166, 255, 169, 182, 131, 
+	188, 140, 141, 176, 178, 180, 183, 184, 
+	190, 191, 129, 171, 175, 181, 182, 163, 
+	170, 172, 173, 172, 184, 190, 158, 128, 
+	143, 160, 175, 144, 145, 150, 155, 157, 
+	158, 159, 135, 139, 141, 168, 171, 189, 
+	160, 182, 186, 191, 129, 131, 133, 134, 
+	140, 143, 184, 186, 165, 166, 128, 129, 
+	130, 132, 133, 134, 135, 136, 139, 140, 
+	141, 144, 145, 146, 147, 150, 151, 152, 
+	153, 154, 156, 176, 178, 128, 130, 184, 
+	255, 135, 190, 131, 175, 187, 255, 128, 
+	130, 167, 180, 179, 128, 130, 179, 255, 
+	129, 137, 141, 255, 190, 172, 183, 159, 
+	170, 188, 128, 131, 190, 191, 151, 128, 
+	132, 135, 136, 139, 141, 162, 163, 166, 
+	172, 176, 180, 181, 191, 128, 134, 176, 
+	255, 132, 255, 175, 181, 184, 255, 129, 
+	155, 158, 255, 129, 255, 171, 183, 157, 
+	171, 175, 182, 184, 191, 146, 167, 169, 
+	182, 171, 172, 189, 190, 176, 180, 176, 
+	182, 145, 190, 143, 146, 178, 157, 158, 
+	133, 134, 137, 168, 169, 170, 165, 169, 
+	173, 178, 187, 255, 131, 132, 140, 169, 
+	174, 255, 130, 132, 128, 182, 187, 255, 
+	173, 180, 182, 255, 132, 155, 159, 161, 
+	175, 128, 163, 165, 128, 134, 136, 152, 
+	155, 161, 163, 164, 166, 170, 144, 150, 
+	132, 138, 145, 146, 151, 166, 169, 0, 
+	127, 176, 255, 131, 137, 191, 145, 189, 
+	135, 129, 130, 132, 133, 144, 154, 176, 
+	139, 159, 150, 156, 159, 164, 167, 168, 
+	170, 173, 145, 176, 255, 139, 255, 166, 
+	176, 171, 179, 160, 161, 163, 164, 165, 
+	166, 167, 169, 171, 172, 173, 174, 175, 
+	176, 177, 178, 179, 180, 181, 182, 183, 
+	184, 185, 186, 187, 188, 189, 190, 191, 
+	168, 170, 150, 153, 155, 163, 165, 167, 
+	169, 173, 153, 155, 148, 161, 163, 255, 
+	131, 187, 189, 132, 185, 190, 255, 141, 
+	144, 129, 136, 145, 151, 152, 161, 162, 
+	163, 164, 255, 129, 188, 190, 130, 131, 
+	191, 255, 141, 151, 129, 132, 133, 134, 
+	137, 138, 142, 161, 162, 163, 164, 255, 
+	131, 188, 129, 130, 190, 255, 145, 181, 
+	129, 130, 131, 134, 135, 136, 137, 138, 
+	139, 141, 142, 175, 176, 177, 178, 255, 
+	134, 138, 141, 129, 136, 142, 161, 162, 
+	163, 164, 255, 129, 188, 130, 131, 190, 
+	191, 128, 141, 129, 132, 135, 136, 139, 
+	140, 150, 151, 162, 163, 130, 190, 191, 
+	128, 141, 151, 129, 130, 134, 136, 138, 
+	140, 128, 129, 131, 190, 255, 133, 137, 
+	129, 132, 142, 148, 151, 161, 164, 255, 
+	129, 188, 190, 191, 130, 131, 130, 134, 
+	128, 132, 135, 136, 138, 139, 140, 141, 
+	149, 150, 162, 163, 129, 190, 130, 131, 
+	191, 255, 133, 137, 141, 151, 129, 132, 
+	142, 161, 162, 163, 164, 255, 138, 143, 
+	150, 159, 144, 145, 146, 148, 152, 158, 
+	178, 179, 177, 179, 180, 186, 135, 142, 
+	177, 179, 180, 185, 187, 188, 136, 141, 
+	181, 183, 185, 152, 153, 190, 191, 191, 
+	177, 190, 128, 132, 134, 135, 141, 151, 
+	153, 188, 134, 128, 129, 130, 141, 156, 
+	157, 158, 159, 160, 162, 164, 168, 169, 
+	170, 172, 173, 174, 175, 176, 179, 183, 
+	177, 173, 183, 185, 186, 187, 188, 189, 
+	190, 150, 151, 152, 153, 158, 160, 177, 
+	180, 130, 132, 141, 157, 133, 134, 157, 
+	159, 146, 148, 178, 180, 146, 147, 178, 
+	179, 182, 180, 189, 190, 255, 134, 157, 
+	137, 147, 148, 255, 139, 141, 169, 133, 
+	134, 178, 160, 162, 163, 166, 167, 168, 
+	169, 171, 176, 184, 185, 187, 155, 151, 
+	152, 153, 154, 150, 160, 162, 191, 149, 
+	151, 152, 158, 165, 172, 173, 178, 179, 
+	188, 176, 190, 132, 181, 187, 128, 131, 
+	180, 188, 189, 255, 130, 133, 170, 171, 
+	179, 180, 255, 130, 161, 170, 128, 129, 
+	162, 165, 166, 167, 168, 173, 167, 173, 
+	166, 169, 170, 174, 175, 177, 178, 179, 
+	164, 171, 172, 179, 180, 181, 182, 183, 
+	161, 173, 180, 144, 146, 148, 168, 178, 
+	179, 184, 185, 128, 181, 187, 191, 128, 
+	131, 179, 181, 183, 140, 141, 144, 176, 
+	175, 177, 191, 160, 191, 128, 130, 170, 
+	175, 153, 154, 153, 154, 155, 160, 162, 
+	163, 164, 165, 166, 167, 168, 169, 170, 
+	171, 175, 175, 178, 180, 189, 158, 159, 
+	176, 177, 130, 134, 139, 167, 163, 164, 
+	165, 166, 132, 133, 134, 159, 160, 177, 
+	178, 255, 166, 173, 135, 145, 146, 147, 
+	131, 179, 188, 128, 130, 180, 181, 182, 
+	185, 186, 255, 165, 129, 255, 169, 174, 
+	175, 176, 177, 178, 179, 180, 181, 182, 
+	131, 140, 141, 188, 176, 178, 180, 183, 
+	184, 190, 191, 129, 171, 181, 182, 172, 
+	173, 174, 175, 165, 168, 172, 173, 163, 
+	170, 172, 184, 190, 158, 128, 143, 160, 
+	175, 144, 145, 150, 155, 157, 158, 159, 
+	135, 139, 141, 168, 171, 189, 160, 182, 
+	186, 191, 129, 131, 133, 134, 140, 143, 
+	184, 186, 165, 166, 128, 129, 130, 132, 
+	133, 134, 135, 136, 139, 140, 141, 144, 
+	145, 146, 147, 150, 151, 152, 153, 154, 
+	156, 176, 178, 129, 128, 130, 184, 255, 
+	135, 190, 130, 131, 175, 176, 178, 183, 
+	184, 187, 255, 172, 128, 130, 167, 180, 
+	179, 130, 128, 129, 179, 181, 182, 190, 
+	191, 255, 129, 137, 138, 140, 141, 255, 
+	180, 190, 172, 174, 175, 177, 178, 181, 
+	182, 183, 159, 160, 162, 163, 170, 188, 
+	190, 191, 128, 129, 130, 131, 128, 151, 
+	129, 132, 135, 136, 139, 141, 162, 163, 
+	166, 172, 176, 180, 181, 183, 184, 191, 
+	133, 128, 129, 130, 134, 176, 185, 189, 
+	177, 178, 179, 186, 187, 190, 191, 255, 
+	129, 132, 255, 175, 190, 176, 177, 178, 
+	181, 184, 187, 188, 255, 129, 155, 158, 
+	255, 189, 176, 178, 179, 186, 187, 190, 
+	191, 255, 129, 255, 172, 182, 171, 173, 
+	174, 175, 176, 183, 166, 157, 159, 160, 
+	161, 162, 171, 175, 190, 176, 182, 184, 
+	191, 169, 177, 180, 146, 167, 170, 182, 
+	171, 172, 189, 190, 176, 180, 176, 182, 
+	143, 146, 178, 157, 158, 133, 134, 137, 
+	168, 169, 170, 166, 173, 165, 169, 174, 
+	178, 187, 255, 131, 132, 140, 169, 174, 
+	255, 130, 132, 128, 182, 187, 255, 173, 
+	180, 182, 255, 132, 155, 159, 161, 175, 
+	128, 163, 165, 128, 134, 136, 152, 155, 
+	161, 163, 164, 166, 170, 144, 150, 132, 
+	138, 143, 187, 191, 160, 128, 129, 132, 
+	135, 133, 134, 160, 255, 192, 255, 139, 
+	168, 160, 128, 129, 132, 135, 133, 134, 
+	160, 255, 192, 255, 144, 145, 150, 155, 
+	157, 158, 128, 191, 173, 128, 159, 160, 
+	191, 156, 128, 133, 134, 191, 0, 127, 
+	176, 255, 131, 137, 191, 145, 189, 135, 
+	129, 130, 132, 133, 144, 154, 176, 139, 
+	159, 150, 156, 159, 164, 167, 168, 170, 
+	173, 145, 176, 255, 139, 255, 166, 176, 
+	171, 179, 160, 161, 163, 164, 165, 167, 
+	169, 171, 173, 174, 175, 176, 177, 179, 
+	180, 181, 182, 183, 184, 185, 186, 187, 
+	188, 189, 190, 191, 166, 170, 172, 178, 
+	150, 153, 155, 163, 165, 167, 169, 173, 
+	153, 155, 148, 161, 163, 255, 189, 132, 
+	185, 144, 152, 161, 164, 255, 188, 129, 
+	131, 190, 255, 133, 134, 137, 138, 142, 
+	150, 152, 161, 164, 255, 131, 134, 137, 
+	138, 142, 144, 146, 175, 178, 180, 182, 
+	255, 134, 138, 142, 161, 164, 255, 188, 
+	129, 131, 190, 191, 128, 132, 135, 136, 
+	139, 141, 150, 151, 162, 163, 130, 190, 
+	191, 151, 128, 130, 134, 136, 138, 141, 
+	128, 131, 190, 255, 133, 137, 142, 148, 
+	151, 161, 164, 255, 128, 132, 134, 136, 
+	138, 141, 149, 150, 162, 163, 129, 131, 
+	190, 255, 133, 137, 142, 150, 152, 161, 
+	164, 255, 130, 131, 138, 150, 143, 148, 
+	152, 159, 178, 179, 177, 179, 186, 135, 
+	142, 177, 179, 185, 187, 188, 136, 141, 
+	181, 183, 185, 152, 153, 190, 191, 177, 
+	191, 128, 132, 134, 135, 141, 151, 153, 
+	188, 134, 128, 129, 130, 141, 156, 157, 
+	158, 159, 160, 162, 164, 168, 169, 170, 
+	172, 173, 174, 175, 176, 179, 183, 173, 
+	183, 185, 190, 150, 153, 158, 160, 177, 
+	180, 130, 141, 157, 132, 134, 157, 159, 
+	146, 148, 178, 180, 146, 147, 178, 179, 
+	180, 255, 148, 156, 158, 255, 139, 141, 
+	169, 133, 134, 160, 171, 176, 187, 151, 
+	155, 160, 162, 191, 149, 158, 165, 188, 
+	176, 190, 128, 132, 180, 255, 133, 170, 
+	180, 255, 128, 130, 161, 173, 166, 179, 
+	164, 183, 173, 144, 146, 148, 168, 178, 
+	180, 184, 185, 128, 181, 187, 191, 128, 
+	131, 179, 181, 183, 140, 141, 128, 131, 
+	157, 179, 181, 183, 144, 176, 164, 175, 
+	177, 191, 160, 191, 128, 130, 170, 175, 
+	153, 154, 153, 154, 155, 160, 162, 163, 
+	164, 165, 166, 167, 168, 169, 170, 171, 
+	175, 175, 178, 180, 189, 158, 159, 176, 
+	177, 130, 134, 139, 163, 167, 128, 129, 
+	180, 255, 134, 159, 178, 255, 166, 173, 
+	135, 147, 128, 131, 179, 255, 129, 164, 
+	166, 255, 169, 182, 131, 188, 140, 141, 
+	176, 178, 180, 183, 184, 190, 191, 129, 
+	171, 175, 181, 182, 163, 170, 172, 173, 
+	172, 184, 190, 158, 128, 143, 160, 175, 
+	144, 145, 150, 155, 157, 158, 159, 135, 
+	139, 141, 168, 171, 189, 160, 182, 186, 
+	191, 129, 131, 133, 134, 140, 143, 184, 
+	186, 165, 166, 128, 129, 130, 132, 133, 
+	134, 135, 136, 139, 140, 141, 144, 145, 
+	146, 147, 150, 151, 152, 153, 154, 156, 
+	176, 178, 128, 130, 184, 255, 135, 190, 
+	131, 175, 187, 255, 128, 130, 167, 180, 
+	179, 128, 130, 179, 255, 129, 137, 141, 
+	255, 190, 172, 183, 159, 170, 188, 128, 
+	131, 190, 191, 151, 128, 132, 135, 136, 
+	139, 141, 162, 163, 166, 172, 176, 180, 
+	181, 191, 128, 134, 176, 255, 132, 255, 
+	175, 181, 184, 255, 129, 155, 158, 255, 
+	129, 255, 171, 183, 157, 171, 175, 182, 
+	184, 191, 146, 167, 169, 182, 171, 172, 
+	189, 190, 176, 180, 176, 182, 145, 190, 
+	143, 146, 178, 157, 158, 133, 134, 137, 
+	168, 169, 170, 165, 169, 173, 178, 187, 
+	255, 131, 132, 140, 169, 174, 255, 130, 
+	132, 128, 182, 187, 255, 173, 180, 182, 
+	255, 132, 155, 159, 161, 175, 128, 163, 
+	165, 128, 134, 136, 152, 155, 161, 163, 
+	164, 166, 170, 144, 150, 132, 138, 145, 
+	146, 151, 166, 169, 128, 255, 176, 255, 
+	131, 137, 191, 145, 189, 135, 129, 130, 
+	132, 133, 144, 154, 176, 139, 159, 150, 
+	156, 159, 164, 167, 168, 170, 173, 145, 
+	176, 255, 139, 255, 166, 176, 171, 179, 
+	160, 161, 163, 164, 165, 166, 167, 169, 
+	171, 172, 173, 174, 175, 176, 177, 178, 
+	179, 180, 181, 182, 183, 184, 185, 186, 
+	187, 188, 189, 190, 191, 168, 170, 150, 
+	153, 155, 163, 165, 167, 169, 173, 153, 
+	155, 148, 161, 163, 255, 131, 187, 189, 
+	132, 185, 190, 255, 141, 144, 129, 136, 
+	145, 151, 152, 161, 162, 163, 164, 255, 
+	129, 188, 190, 130, 131, 191, 255, 141, 
+	151, 129, 132, 133, 134, 137, 138, 142, 
+	161, 162, 163, 164, 255, 131, 188, 129, 
+	130, 190, 255, 145, 181, 129, 130, 131, 
+	134, 135, 136, 137, 138, 139, 141, 142, 
+	175, 176, 177, 178, 255, 134, 138, 141, 
+	129, 136, 142, 161, 162, 163, 164, 255, 
+	129, 188, 130, 131, 190, 191, 128, 141, 
+	129, 132, 135, 136, 139, 140, 150, 151, 
+	162, 163, 130, 190, 191, 128, 141, 151, 
+	129, 130, 134, 136, 138, 140, 128, 129, 
+	131, 190, 255, 133, 137, 129, 132, 142, 
+	148, 151, 161, 164, 255, 129, 188, 190, 
+	191, 130, 131, 130, 134, 128, 132, 135, 
+	136, 138, 139, 140, 141, 149, 150, 162, 
+	163, 129, 190, 130, 131, 191, 255, 133, 
+	137, 141, 151, 129, 132, 142, 161, 162, 
+	163, 164, 255, 138, 143, 150, 159, 144, 
+	145, 146, 148, 152, 158, 178, 179, 177, 
+	179, 180, 186, 135, 142, 177, 179, 180, 
+	185, 187, 188, 136, 141, 181, 183, 185, 
+	152, 153, 190, 191, 191, 177, 190, 128, 
+	132, 134, 135, 141, 151, 153, 188, 134, 
+	128, 129, 130, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 177, 173, 183, 
+	185, 186, 187, 188, 189, 190, 150, 151, 
+	152, 153, 158, 160, 177, 180, 130, 132, 
+	141, 157, 133, 134, 157, 159, 146, 148, 
+	178, 180, 146, 147, 178, 179, 182, 180, 
+	189, 190, 255, 134, 157, 137, 147, 148, 
+	255, 139, 141, 169, 133, 134, 178, 160, 
+	162, 163, 166, 167, 168, 169, 171, 176, 
+	184, 185, 187, 155, 151, 152, 153, 154, 
+	150, 160, 162, 191, 149, 151, 152, 158, 
+	165, 172, 173, 178, 179, 188, 176, 190, 
+	132, 181, 187, 128, 131, 180, 188, 189, 
+	255, 130, 133, 170, 171, 179, 180, 255, 
+	130, 161, 170, 128, 129, 162, 165, 166, 
+	167, 168, 173, 167, 173, 166, 169, 170, 
+	174, 175, 177, 178, 179, 164, 171, 172, 
+	179, 180, 181, 182, 183, 161, 173, 180, 
+	144, 146, 148, 168, 178, 179, 184, 185, 
+	128, 181, 187, 191, 128, 131, 179, 181, 
+	183, 140, 141, 144, 176, 175, 177, 191, 
+	160, 191, 128, 130, 170, 175, 153, 154, 
+	153, 154, 155, 160, 162, 163, 164, 165, 
+	166, 167, 168, 169, 170, 171, 175, 175, 
+	178, 180, 189, 158, 159, 176, 177, 130, 
+	134, 139, 167, 163, 164, 165, 166, 132, 
+	133, 134, 159, 160, 177, 178, 255, 166, 
+	173, 135, 145, 146, 147, 131, 179, 188, 
+	128, 130, 180, 181, 182, 185, 186, 255, 
+	165, 129, 255, 169, 174, 175, 176, 177, 
+	178, 179, 180, 181, 182, 131, 140, 141, 
+	188, 176, 178, 180, 183, 184, 190, 191, 
+	129, 171, 181, 182, 172, 173, 174, 175, 
+	165, 168, 172, 173, 163, 170, 172, 184, 
+	190, 158, 128, 143, 160, 175, 144, 145, 
+	150, 155, 157, 158, 159, 135, 139, 141, 
+	168, 171, 189, 160, 182, 186, 191, 129, 
+	131, 133, 134, 140, 143, 184, 186, 165, 
+	166, 128, 129, 130, 132, 133, 134, 135, 
+	136, 139, 140, 141, 144, 145, 146, 147, 
+	150, 151, 152, 153, 154, 156, 176, 178, 
+	129, 128, 130, 184, 255, 135, 190, 130, 
+	131, 175, 176, 178, 183, 184, 187, 255, 
+	172, 128, 130, 167, 180, 179, 130, 128, 
+	129, 179, 181, 182, 190, 191, 255, 129, 
+	137, 138, 140, 141, 255, 180, 190, 172, 
+	174, 175, 177, 178, 181, 182, 183, 159, 
+	160, 162, 163, 170, 188, 190, 191, 128, 
+	129, 130, 131, 128, 151, 129, 132, 135, 
+	136, 139, 141, 162, 163, 166, 172, 176, 
+	180, 181, 183, 184, 191, 133, 128, 129, 
+	130, 134, 176, 185, 189, 177, 178, 179, 
+	186, 187, 190, 191, 255, 129, 132, 255, 
+	175, 190, 176, 177, 178, 181, 184, 187, 
+	188, 255, 129, 155, 158, 255, 189, 176, 
+	178, 179, 186, 187, 190, 191, 255, 129, 
+	255, 172, 182, 171, 173, 174, 175, 176, 
+	183, 166, 157, 159, 160, 161, 162, 171, 
+	175, 190, 176, 182, 184, 191, 169, 177, 
+	180, 146, 167, 170, 182, 171, 172, 189, 
+	190, 176, 180, 176, 182, 143, 146, 178, 
+	157, 158, 133, 134, 137, 168, 169, 170, 
+	166, 173, 165, 169, 174, 178, 187, 255, 
+	131, 132, 140, 169, 174, 255, 130, 132, 
+	128, 182, 187, 255, 173, 180, 182, 255, 
+	132, 155, 159, 161, 175, 128, 163, 165, 
+	128, 134, 136, 152, 155, 161, 163, 164, 
+	166, 170, 144, 150, 132, 138, 143, 187, 
+	191, 160, 128, 129, 132, 135, 133, 134, 
+	160, 255, 192, 255, 139, 168, 160, 128, 
+	129, 132, 135, 133, 134, 160, 255, 192, 
+	255, 144, 145, 150, 155, 157, 158, 128, 
+	191, 160, 172, 174, 191, 128, 133, 134, 
+	155, 157, 191, 157, 128, 191, 143, 128, 
+	191, 163, 181, 128, 191, 162, 128, 191, 
+	142, 128, 191, 132, 133, 134, 135, 160, 
+	128, 191, 128, 255, 128, 129, 130, 132, 
+	133, 134, 141, 156, 157, 158, 159, 160, 
+	162, 164, 168, 169, 170, 172, 173, 174, 
+	175, 176, 179, 183, 160, 255, 128, 129, 
+	130, 133, 134, 135, 141, 156, 157, 158, 
+	159, 160, 162, 164, 168, 169, 170, 172, 
+	173, 174, 175, 176, 179, 183, 160, 255, 
+	168, 255, 128, 129, 130, 134, 135, 141, 
+	156, 157, 158, 159, 160, 162, 164, 168, 
+	169, 170, 172, 173, 174, 175, 176, 179, 
+	183, 168, 255, 192, 255, 159, 139, 187, 
+	158, 159, 176, 255, 135, 138, 139, 187, 
+	188, 255, 168, 255, 153, 154, 155, 160, 
+	162, 163, 164, 165, 166, 167, 168, 169, 
+	170, 171, 175, 177, 178, 179, 180, 181, 
+	182, 184, 185, 186, 187, 188, 189, 191, 
+	176, 190, 192, 255, 135, 147, 160, 188, 
+	128, 156, 184, 129, 255, 128, 129, 130, 
+	133, 134, 141, 156, 157, 158, 159, 160, 
+	162, 164, 168, 169, 170, 172, 173, 174, 
+	175, 176, 179, 183, 158, 159, 135, 255, 
+	148, 176, 140, 168, 132, 160, 188, 152, 
+	180, 144, 172, 136, 164, 192, 255, 129, 
+	130, 131, 132, 133, 134, 136, 137, 138, 
+	139, 140, 141, 143, 144, 145, 146, 147, 
+	148, 150, 151, 152, 153, 154, 155, 157, 
+	158, 159, 160, 161, 162, 164, 165, 166, 
+	167, 168, 169, 171, 172, 173, 174, 175, 
+	176, 178, 179, 180, 181, 182, 183, 185, 
+	186, 187, 188, 189, 190, 128, 191, 129, 
+	130, 131, 132, 133, 134, 136, 137, 138, 
+	139, 140, 141, 143, 144, 145, 146, 147, 
+	148, 150, 151, 152, 153, 154, 155, 157, 
+	158, 159, 160, 161, 162, 164, 165, 166, 
+	167, 168, 169, 171, 172, 173, 174, 175, 
+	176, 178, 179, 180, 181, 182, 183, 185, 
+	186, 187, 188, 189, 190, 128, 191, 129, 
+	130, 131, 132, 133, 134, 136, 137, 138, 
+	139, 140, 141, 143, 144, 145, 146, 147, 
+	148, 150, 151, 152, 153, 154, 155, 157, 
+	158, 159, 128, 156, 160, 255, 136, 164, 
+	175, 176, 255, 128, 141, 143, 191, 128, 
+	129, 152, 155, 156, 130, 191, 140, 141, 
+	128, 138, 144, 167, 175, 191, 128, 159, 
+	176, 191, 157, 128, 191, 185, 128, 191, 
+	128, 137, 138, 141, 142, 191, 128, 191, 
+	165, 177, 178, 179, 180, 181, 182, 184, 
+	185, 186, 187, 188, 189, 191, 128, 175, 
+	176, 190, 192, 255, 128, 159, 160, 188, 
+	189, 191, 128, 156, 184, 129, 255, 148, 
+	176, 140, 168, 132, 160, 188, 152, 180, 
+	144, 172, 136, 164, 192, 255, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 160, 161, 162, 164, 165, 166, 167, 
+	168, 169, 171, 172, 173, 174, 175, 176, 
+	178, 179, 180, 181, 182, 183, 185, 186, 
+	187, 188, 189, 190, 128, 191, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 160, 161, 162, 164, 165, 166, 167, 
+	168, 169, 171, 172, 173, 174, 175, 176, 
+	178, 179, 180, 181, 182, 183, 185, 186, 
+	187, 188, 189, 190, 128, 191, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 128, 156, 160, 255, 136, 164, 175, 
+	176, 255, 135, 138, 139, 187, 188, 191, 
+	192, 255, 187, 191, 128, 190, 128, 190, 
+	188, 128, 175, 190, 191, 145, 155, 157, 
+	159, 128, 191, 130, 135, 128, 191, 189, 
+	128, 191, 128, 129, 130, 131, 132, 191, 
+	178, 128, 191, 128, 159, 164, 191, 133, 
+	128, 191, 128, 178, 187, 191, 135, 142, 
+	143, 145, 146, 149, 150, 153, 154, 155, 
+	164, 128, 191, 128, 165, 166, 191, 144, 
+	145, 150, 155, 157, 158, 159, 135, 166, 
+	191, 133, 128, 191, 128, 130, 131, 132, 
+	133, 137, 138, 139, 140, 191, 174, 188, 
+	128, 129, 130, 131, 132, 133, 134, 144, 
+	145, 165, 166, 169, 170, 175, 176, 184, 
+	185, 191, 128, 132, 170, 129, 135, 136, 
+	191, 181, 186, 128, 191, 144, 128, 148, 
+	149, 150, 151, 191, 128, 132, 133, 135, 
+	136, 138, 139, 143, 144, 191, 163, 128, 
+	179, 180, 182, 183, 191, 128, 129, 191, 
+	166, 176, 191, 128, 151, 152, 158, 159, 
+	178, 179, 185, 186, 187, 188, 190, 128, 
+	191, 160, 128, 191, 128, 129, 135, 132, 
+	134, 128, 175, 157, 128, 191, 143, 128, 
+	191, 163, 181, 128, 191, 162, 128, 191, 
+	142, 128, 191, 132, 133, 134, 135, 160, 
+	128, 191, 0, 127, 128, 255, 176, 255, 
+	131, 137, 191, 145, 189, 135, 129, 130, 
+	132, 133, 144, 154, 176, 139, 159, 150, 
+	156, 159, 164, 167, 168, 170, 173, 145, 
+	176, 255, 139, 255, 166, 176, 171, 179, 
+	160, 161, 163, 164, 165, 167, 169, 171, 
+	173, 174, 175, 176, 177, 179, 180, 181, 
+	182, 183, 184, 185, 186, 187, 188, 189, 
+	190, 191, 166, 170, 172, 178, 150, 153, 
+	155, 163, 165, 167, 169, 173, 153, 155, 
+	148, 161, 163, 255, 189, 132, 185, 144, 
+	152, 161, 164, 255, 188, 129, 131, 190, 
+	255, 133, 134, 137, 138, 142, 150, 152, 
+	161, 164, 255, 131, 134, 137, 138, 142, 
+	144, 146, 175, 178, 180, 182, 255, 134, 
+	138, 142, 161, 164, 255, 188, 129, 131, 
+	190, 191, 128, 132, 135, 136, 139, 141, 
+	150, 151, 162, 163, 130, 190, 191, 151, 
+	128, 130, 134, 136, 138, 141, 128, 131, 
+	190, 255, 133, 137, 142, 148, 151, 161, 
+	164, 255, 128, 132, 134, 136, 138, 141, 
+	149, 150, 162, 163, 129, 131, 190, 255, 
+	133, 137, 142, 150, 152, 161, 164, 255, 
+	130, 131, 138, 150, 143, 148, 152, 159, 
+	178, 179, 177, 179, 186, 135, 142, 177, 
+	179, 185, 187, 188, 136, 141, 181, 183, 
+	185, 152, 153, 190, 191, 177, 191, 128, 
+	132, 134, 135, 141, 151, 153, 188, 134, 
+	128, 129, 130, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 173, 183, 185, 
+	190, 150, 153, 158, 160, 177, 180, 130, 
+	141, 157, 132, 134, 157, 159, 146, 148, 
+	178, 180, 146, 147, 178, 179, 180, 255, 
+	148, 156, 158, 255, 139, 141, 169, 133, 
+	134, 160, 171, 176, 187, 151, 155, 160, 
+	162, 191, 149, 158, 165, 188, 176, 190, 
+	128, 132, 180, 255, 133, 170, 180, 255, 
+	128, 130, 161, 173, 166, 179, 164, 183, 
+	173, 144, 146, 148, 168, 178, 180, 184, 
+	185, 128, 181, 187, 191, 128, 131, 179, 
+	181, 183, 140, 141, 128, 131, 157, 179, 
+	181, 183, 144, 176, 164, 175, 177, 191, 
+	160, 191, 128, 130, 170, 175, 153, 154, 
+	153, 154, 155, 160, 162, 163, 164, 165, 
+	166, 167, 168, 169, 170, 171, 175, 175, 
+	178, 180, 189, 158, 159, 176, 177, 130, 
+	134, 139, 163, 167, 128, 129, 180, 255, 
+	134, 159, 178, 255, 166, 173, 135, 147, 
+	128, 131, 179, 255, 129, 164, 166, 255, 
+	169, 182, 131, 188, 140, 141, 176, 178, 
+	180, 183, 184, 190, 191, 129, 171, 175, 
+	181, 182, 163, 170, 172, 173, 172, 184, 
+	190, 158, 128, 143, 160, 175, 144, 145, 
+	150, 155, 157, 158, 159, 135, 139, 141, 
+	168, 171, 189, 160, 182, 186, 191, 129, 
+	131, 133, 134, 140, 143, 184, 186, 165, 
+	166, 128, 129, 130, 132, 133, 134, 135, 
+	136, 139, 140, 141, 144, 145, 146, 147, 
+	150, 151, 152, 153, 154, 156, 176, 178, 
+	128, 130, 184, 255, 135, 190, 131, 175, 
+	187, 255, 128, 130, 167, 180, 179, 128, 
+	130, 179, 255, 129, 137, 141, 255, 190, 
+	172, 183, 159, 170, 188, 128, 131, 190, 
+	191, 151, 128, 132, 135, 136, 139, 141, 
+	162, 163, 166, 172, 176, 180, 181, 191, 
+	128, 134, 176, 255, 132, 255, 175, 181, 
+	184, 255, 129, 155, 158, 255, 129, 255, 
+	171, 183, 157, 171, 175, 182, 184, 191, 
+	146, 167, 169, 182, 171, 172, 189, 190, 
+	176, 180, 176, 182, 145, 190, 143, 146, 
+	178, 157, 158, 133, 134, 137, 168, 169, 
+	170, 165, 169, 173, 178, 187, 255, 131, 
+	132, 140, 169, 174, 255, 130, 132, 128, 
+	182, 187, 255, 173, 180, 182, 255, 132, 
+	155, 159, 161, 175, 128, 163, 165, 128, 
+	134, 136, 152, 155, 161, 163, 164, 166, 
+	170, 144, 150, 132, 138, 145, 146, 151, 
+	166, 169, 128, 255, 176, 255, 131, 137, 
+	191, 145, 189, 135, 129, 130, 132, 133, 
+	144, 154, 176, 139, 159, 150, 156, 159, 
+	164, 167, 168, 170, 173, 145, 176, 255, 
+	139, 255, 166, 176, 171, 179, 160, 161, 
+	163, 164, 165, 166, 167, 169, 171, 172, 
+	173, 174, 175, 176, 177, 178, 179, 180, 
+	181, 182, 183, 184, 185, 186, 187, 188, 
+	189, 190, 191, 168, 170, 150, 153, 155, 
+	163, 165, 167, 169, 173, 153, 155, 148, 
+	161, 163, 255, 131, 187, 189, 132, 185, 
+	190, 255, 141, 144, 129, 136, 145, 151, 
+	152, 161, 162, 163, 164, 255, 129, 188, 
+	190, 130, 131, 191, 255, 141, 151, 129, 
+	132, 133, 134, 137, 138, 142, 161, 162, 
+	163, 164, 255, 131, 188, 129, 130, 190, 
+	255, 145, 181, 129, 130, 131, 134, 135, 
+	136, 137, 138, 139, 141, 142, 175, 176, 
+	177, 178, 255, 134, 138, 141, 129, 136, 
+	142, 161, 162, 163, 164, 255, 129, 188, 
+	130, 131, 190, 191, 128, 141, 129, 132, 
+	135, 136, 139, 140, 150, 151, 162, 163, 
+	130, 190, 191, 128, 141, 151, 129, 130, 
+	134, 136, 138, 140, 128, 129, 131, 190, 
+	255, 133, 137, 129, 132, 142, 148, 151, 
+	161, 164, 255, 129, 188, 190, 191, 130, 
+	131, 130, 134, 128, 132, 135, 136, 138, 
+	139, 140, 141, 149, 150, 162, 163, 129, 
+	190, 130, 131, 191, 255, 133, 137, 141, 
+	151, 129, 132, 142, 161, 162, 163, 164, 
+	255, 138, 143, 150, 159, 144, 145, 146, 
+	148, 152, 158, 178, 179, 177, 179, 180, 
+	186, 135, 142, 177, 179, 180, 185, 187, 
+	188, 136, 141, 181, 183, 185, 152, 153, 
+	190, 191, 191, 177, 190, 128, 132, 134, 
+	135, 141, 151, 153, 188, 134, 128, 129, 
+	130, 141, 156, 157, 158, 159, 160, 162, 
+	164, 168, 169, 170, 172, 173, 174, 175, 
+	176, 179, 183, 177, 173, 183, 185, 186, 
+	187, 188, 189, 190, 150, 151, 152, 153, 
+	158, 160, 177, 180, 130, 132, 141, 157, 
+	133, 134, 157, 159, 146, 148, 178, 180, 
+	146, 147, 178, 179, 182, 180, 189, 190, 
+	255, 134, 157, 137, 147, 148, 255, 139, 
+	141, 169, 133, 134, 178, 160, 162, 163, 
+	166, 167, 168, 169, 171, 176, 184, 185, 
+	187, 155, 151, 152, 153, 154, 150, 160, 
+	162, 191, 149, 151, 152, 158, 165, 172, 
+	173, 178, 179, 188, 176, 190, 132, 181, 
+	187, 128, 131, 180, 188, 189, 255, 130, 
+	133, 170, 171, 179, 180, 255, 130, 161, 
+	170, 128, 129, 162, 165, 166, 167, 168, 
+	173, 167, 173, 166, 169, 170, 174, 175, 
+	177, 178, 179, 164, 171, 172, 179, 180, 
+	181, 182, 183, 161, 173, 180, 144, 146, 
+	148, 168, 178, 179, 184, 185, 128, 181, 
+	187, 191, 128, 131, 179, 181, 183, 140, 
+	141, 144, 176, 175, 177, 191, 160, 191, 
+	128, 130, 170, 175, 153, 154, 153, 154, 
+	155, 160, 162, 163, 164, 165, 166, 167, 
+	168, 169, 170, 171, 175, 175, 178, 180, 
+	189, 158, 159, 176, 177, 130, 134, 139, 
+	167, 163, 164, 165, 166, 132, 133, 134, 
+	159, 160, 177, 178, 255, 166, 173, 135, 
+	145, 146, 147, 131, 179, 188, 128, 130, 
+	180, 181, 182, 185, 186, 255, 165, 129, 
+	255, 169, 174, 175, 176, 177, 178, 179, 
+	180, 181, 182, 131, 140, 141, 188, 176, 
+	178, 180, 183, 184, 190, 191, 129, 171, 
+	181, 182, 172, 173, 174, 175, 165, 168, 
+	172, 173, 163, 170, 172, 184, 190, 158, 
+	128, 143, 160, 175, 144, 145, 150, 155, 
+	157, 158, 159, 135, 139, 141, 168, 171, 
+	189, 160, 182, 186, 191, 129, 131, 133, 
+	134, 140, 143, 184, 186, 165, 166, 128, 
+	129, 130, 132, 133, 134, 135, 136, 139, 
+	140, 141, 144, 145, 146, 147, 150, 151, 
+	152, 153, 154, 156, 176, 178, 129, 128, 
+	130, 184, 255, 135, 190, 130, 131, 175, 
+	176, 178, 183, 184, 187, 255, 172, 128, 
+	130, 167, 180, 179, 130, 128, 129, 179, 
+	181, 182, 190, 191, 255, 129, 137, 138, 
+	140, 141, 255, 180, 190, 172, 174, 175, 
+	177, 178, 181, 182, 183, 159, 160, 162, 
+	163, 170, 188, 190, 191, 128, 129, 130, 
+	131, 128, 151, 129, 132, 135, 136, 139, 
+	141, 162, 163, 166, 172, 176, 180, 181, 
+	183, 184, 191, 133, 128, 129, 130, 134, 
+	176, 185, 189, 177, 178, 179, 186, 187, 
+	190, 191, 255, 129, 132, 255, 175, 190, 
+	176, 177, 178, 181, 184, 187, 188, 255, 
+	129, 155, 158, 255, 189, 176, 178, 179, 
+	186, 187, 190, 191, 255, 129, 255, 172, 
+	182, 171, 173, 174, 175, 176, 183, 166, 
+	157, 159, 160, 161, 162, 171, 175, 190, 
+	176, 182, 184, 191, 169, 177, 180, 146, 
+	167, 170, 182, 171, 172, 189, 190, 176, 
+	180, 176, 182, 143, 146, 178, 157, 158, 
+	133, 134, 137, 168, 169, 170, 166, 173, 
+	165, 169, 174, 178, 187, 255, 131, 132, 
+	140, 169, 174, 255, 130, 132, 128, 182, 
+	187, 255, 173, 180, 182, 255, 132, 155, 
+	159, 161, 175, 128, 163, 165, 128, 134, 
+	136, 152, 155, 161, 163, 164, 166, 170, 
+	144, 150, 132, 138, 143, 187, 191, 160, 
+	128, 129, 132, 135, 133, 134, 160, 255, 
+	192, 255, 139, 168, 160, 128, 129, 132, 
+	135, 133, 134, 160, 255, 192, 255, 144, 
+	145, 150, 155, 157, 158, 128, 129, 130, 
+	132, 133, 134, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 160, 255, 128, 
+	129, 130, 133, 134, 135, 141, 156, 157, 
+	158, 159, 160, 162, 164, 168, 169, 170, 
+	172, 173, 174, 175, 176, 179, 183, 160, 
+	255, 168, 255, 128, 129, 130, 134, 135, 
+	141, 156, 157, 158, 159, 160, 162, 164, 
+	168, 169, 170, 172, 173, 174, 175, 176, 
+	179, 183, 168, 255, 192, 255, 159, 139, 
+	187, 158, 159, 176, 255, 135, 138, 139, 
+	187, 188, 255, 168, 255, 153, 154, 155, 
+	160, 162, 163, 164, 165, 166, 167, 168, 
+	169, 170, 171, 175, 177, 178, 179, 180, 
+	181, 182, 184, 185, 186, 187, 188, 189, 
+	191, 176, 190, 192, 255, 135, 147, 160, 
+	188, 128, 156, 184, 129, 255, 128, 129, 
+	130, 133, 134, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 158, 159, 135, 
+	255, 148, 176, 140, 168, 132, 160, 188, 
+	152, 180, 144, 172, 136, 164, 192, 255, 
+	129, 130, 131, 132, 133, 134, 136, 137, 
+	138, 139, 140, 141, 143, 144, 145, 146, 
+	147, 148, 150, 151, 152, 153, 154, 155, 
+	157, 158, 159, 160, 161, 162, 164, 165, 
+	166, 167, 168, 169, 171, 172, 173, 174, 
+	175, 176, 178, 179, 180, 181, 182, 183, 
+	185, 186, 187, 188, 189, 190, 128, 191, 
+	129, 130, 131, 132, 133, 134, 136, 137, 
+	138, 139, 140, 141, 143, 144, 145, 146, 
+	147, 148, 150, 151, 152, 153, 154, 155, 
+	157, 158, 159, 160, 161, 162, 164, 165, 
+	166, 167, 168, 169, 171, 172, 173, 174, 
+	175, 176, 178, 179, 180, 181, 182, 183, 
+	185, 186, 187, 188, 189, 190, 128, 191, 
+	129, 130, 131, 132, 133, 134, 136, 137, 
+	138, 139, 140, 141, 143, 144, 145, 146, 
+	147, 148, 150, 151, 152, 153, 154, 155, 
+	157, 158, 159, 128, 156, 160, 255, 136, 
+	164, 175, 176, 255, 142, 128, 191, 128, 
+	129, 152, 155, 156, 130, 191, 139, 141, 
+	128, 140, 142, 143, 144, 167, 168, 174, 
+	175, 191, 128, 255, 176, 255, 131, 137, 
+	191, 145, 189, 135, 129, 130, 132, 133, 
+	144, 154, 176, 139, 159, 150, 156, 159, 
+	164, 167, 168, 170, 173, 145, 176, 255, 
+	139, 255, 166, 176, 171, 179, 160, 161, 
+	163, 164, 165, 167, 169, 171, 173, 174, 
+	175, 176, 177, 179, 180, 181, 182, 183, 
+	184, 185, 186, 187, 188, 189, 190, 191, 
+	166, 170, 172, 178, 150, 153, 155, 163, 
+	165, 167, 169, 173, 153, 155, 148, 161, 
+	163, 255, 189, 132, 185, 144, 152, 161, 
+	164, 255, 188, 129, 131, 190, 255, 133, 
+	134, 137, 138, 142, 150, 152, 161, 164, 
+	255, 131, 134, 137, 138, 142, 144, 146, 
+	175, 178, 180, 182, 255, 134, 138, 142, 
+	161, 164, 255, 188, 129, 131, 190, 191, 
+	128, 132, 135, 136, 139, 141, 150, 151, 
+	162, 163, 130, 190, 191, 151, 128, 130, 
+	134, 136, 138, 141, 128, 131, 190, 255, 
+	133, 137, 142, 148, 151, 161, 164, 255, 
+	128, 132, 134, 136, 138, 141, 149, 150, 
+	162, 163, 129, 131, 190, 255, 133, 137, 
+	142, 150, 152, 161, 164, 255, 130, 131, 
+	138, 150, 143, 148, 152, 159, 178, 179, 
+	177, 179, 186, 135, 142, 177, 179, 185, 
+	187, 188, 136, 141, 181, 183, 185, 152, 
+	153, 190, 191, 177, 191, 128, 132, 134, 
+	135, 141, 151, 153, 188, 134, 128, 129, 
+	130, 141, 156, 157, 158, 159, 160, 162, 
+	164, 168, 169, 170, 172, 173, 174, 175, 
+	176, 179, 183, 173, 183, 185, 190, 150, 
+	153, 158, 160, 177, 180, 130, 141, 157, 
+	132, 134, 157, 159, 146, 148, 178, 180, 
+	146, 147, 178, 179, 180, 255, 148, 156, 
+	158, 255, 139, 141, 169, 133, 134, 160, 
+	171, 176, 187, 151, 155, 160, 162, 191, 
+	149, 158, 165, 188, 176, 190, 128, 132, 
+	180, 255, 133, 170, 180, 255, 128, 130, 
+	161, 173, 166, 179, 164, 183, 173, 144, 
+	146, 148, 168, 178, 180, 184, 185, 128, 
+	181, 187, 191, 128, 131, 179, 181, 183, 
+	140, 141, 144, 176, 175, 177, 191, 160, 
+	191, 128, 130, 170, 175, 153, 154, 153, 
+	154, 155, 160, 162, 163, 164, 165, 166, 
+	167, 168, 169, 170, 171, 175, 175, 178, 
+	180, 189, 158, 159, 176, 177, 130, 134, 
+	139, 163, 167, 128, 129, 180, 255, 134, 
+	159, 178, 255, 166, 173, 135, 147, 128, 
+	131, 179, 255, 129, 164, 166, 255, 169, 
+	182, 131, 188, 140, 141, 176, 178, 180, 
+	183, 184, 190, 191, 129, 171, 175, 181, 
+	182, 163, 170, 172, 173, 172, 184, 190, 
+	158, 128, 143, 160, 175, 144, 145, 150, 
+	155, 157, 158, 135, 139, 141, 168, 171, 
+	189, 160, 182, 186, 191, 129, 131, 133, 
+	134, 140, 143, 184, 186, 165, 166, 128, 
+	129, 130, 132, 133, 134, 135, 136, 139, 
+	140, 141, 144, 145, 146, 147, 150, 151, 
+	152, 153, 154, 156, 176, 178, 128, 130, 
+	184, 255, 135, 190, 131, 175, 187, 255, 
+	128, 130, 167, 180, 179, 128, 130, 179, 
+	255, 129, 137, 141, 255, 190, 172, 183, 
+	159, 170, 188, 128, 131, 190, 191, 151, 
+	128, 132, 135, 136, 139, 141, 162, 163, 
+	166, 172, 176, 180, 181, 191, 128, 134, 
+	176, 255, 132, 255, 175, 181, 184, 255, 
+	129, 155, 158, 255, 129, 255, 171, 183, 
+	157, 171, 175, 182, 184, 191, 146, 167, 
+	169, 182, 171, 172, 189, 190, 176, 180, 
+	176, 182, 145, 190, 143, 146, 178, 157, 
+	158, 133, 134, 137, 168, 169, 170, 165, 
+	169, 173, 178, 187, 255, 131, 132, 140, 
+	169, 174, 255, 130, 132, 128, 182, 187, 
+	255, 173, 180, 182, 255, 132, 155, 159, 
+	161, 175, 128, 163, 165, 128, 134, 136, 
+	152, 155, 161, 163, 164, 166, 170, 144, 
+	150, 132, 138, 160, 128, 129, 132, 135, 
+	133, 134, 160, 255, 192, 255, 128, 131, 
+	157, 179, 181, 183, 164, 144, 145, 150, 
+	155, 157, 158, 159, 145, 146, 151, 166, 
+	169, 128, 255, 176, 255, 131, 137, 191, 
+	145, 189, 135, 129, 130, 132, 133, 144, 
+	154, 176, 139, 159, 150, 156, 159, 164, 
+	167, 168, 170, 173, 145, 176, 255, 139, 
+	255, 166, 176, 171, 179, 160, 161, 163, 
+	164, 165, 166, 167, 169, 171, 172, 173, 
+	174, 175, 176, 177, 178, 179, 180, 181, 
+	182, 183, 184, 185, 186, 187, 188, 189, 
+	190, 191, 168, 170, 150, 153, 155, 163, 
+	165, 167, 169, 173, 153, 155, 148, 161, 
+	163, 255, 131, 187, 189, 132, 185, 190, 
+	255, 141, 144, 129, 136, 145, 151, 152, 
+	161, 162, 163, 164, 255, 129, 188, 190, 
+	130, 131, 191, 255, 141, 151, 129, 132, 
+	133, 134, 137, 138, 142, 161, 162, 163, 
+	164, 255, 131, 188, 129, 130, 190, 255, 
+	145, 181, 129, 130, 131, 134, 135, 136, 
+	137, 138, 139, 141, 142, 175, 176, 177, 
+	178, 255, 134, 138, 141, 129, 136, 142, 
+	161, 162, 163, 164, 255, 129, 188, 130, 
+	131, 190, 191, 128, 141, 129, 132, 135, 
+	136, 139, 140, 150, 151, 162, 163, 130, 
+	190, 191, 128, 141, 151, 129, 130, 134, 
+	136, 138, 140, 128, 129, 131, 190, 255, 
+	133, 137, 129, 132, 142, 148, 151, 161, 
+	164, 255, 129, 188, 190, 191, 130, 131, 
+	130, 134, 128, 132, 135, 136, 138, 139, 
+	140, 141, 149, 150, 162, 163, 129, 190, 
+	130, 131, 191, 255, 133, 137, 141, 151, 
+	129, 132, 142, 161, 162, 163, 164, 255, 
+	138, 143, 150, 159, 144, 145, 146, 148, 
+	152, 158, 178, 179, 177, 179, 180, 186, 
+	135, 142, 177, 179, 180, 185, 187, 188, 
+	136, 141, 181, 183, 185, 152, 153, 190, 
+	191, 191, 177, 190, 128, 132, 134, 135, 
+	141, 151, 153, 188, 134, 128, 129, 130, 
+	141, 156, 157, 158, 159, 160, 162, 164, 
+	168, 169, 170, 172, 173, 174, 175, 176, 
+	179, 183, 177, 173, 183, 185, 186, 187, 
+	188, 189, 190, 150, 151, 152, 153, 158, 
+	160, 177, 180, 130, 132, 141, 157, 133, 
+	134, 157, 159, 146, 148, 178, 180, 146, 
+	147, 178, 179, 182, 180, 189, 190, 255, 
+	134, 157, 137, 147, 148, 255, 139, 141, 
+	169, 133, 134, 178, 160, 162, 163, 166, 
+	167, 168, 169, 171, 176, 184, 185, 187, 
+	155, 151, 152, 153, 154, 150, 160, 162, 
+	191, 149, 151, 152, 158, 165, 172, 173, 
+	178, 179, 188, 176, 190, 132, 181, 187, 
+	128, 131, 180, 188, 189, 255, 130, 133, 
+	170, 171, 179, 180, 255, 130, 161, 170, 
+	128, 129, 162, 165, 166, 167, 168, 173, 
+	167, 173, 166, 169, 170, 174, 175, 177, 
+	178, 179, 164, 171, 172, 179, 180, 181, 
+	182, 183, 161, 173, 180, 144, 146, 148, 
+	168, 178, 179, 184, 185, 128, 181, 187, 
+	191, 128, 131, 179, 181, 183, 140, 141, 
+	144, 176, 175, 177, 191, 160, 191, 128, 
+	130, 170, 175, 153, 154, 153, 154, 155, 
+	160, 162, 163, 164, 165, 166, 167, 168, 
+	169, 170, 171, 175, 175, 178, 180, 189, 
+	158, 159, 176, 177, 130, 134, 139, 167, 
+	163, 164, 165, 166, 132, 133, 134, 159, 
+	160, 177, 178, 255, 166, 173, 135, 145, 
+	146, 147, 131, 179, 188, 128, 130, 180, 
+	181, 182, 185, 186, 255, 165, 129, 255, 
+	169, 174, 175, 176, 177, 178, 179, 180, 
+	181, 182, 131, 140, 141, 188, 176, 178, 
+	180, 183, 184, 190, 191, 129, 171, 181, 
+	182, 172, 173, 174, 175, 165, 168, 172, 
+	173, 163, 170, 172, 184, 190, 158, 128, 
+	143, 160, 175, 144, 145, 150, 155, 157, 
+	158, 159, 135, 139, 141, 168, 171, 189, 
+	160, 182, 186, 191, 129, 131, 133, 134, 
+	140, 143, 184, 186, 165, 166, 128, 129, 
+	130, 132, 133, 134, 135, 136, 139, 140, 
+	141, 144, 145, 146, 147, 150, 151, 152, 
+	153, 154, 156, 176, 178, 129, 128, 130, 
+	184, 255, 135, 190, 130, 131, 175, 176, 
+	178, 183, 184, 187, 255, 172, 128, 130, 
+	167, 180, 179, 130, 128, 129, 179, 181, 
+	182, 190, 191, 255, 129, 137, 138, 140, 
+	141, 255, 180, 190, 172, 174, 175, 177, 
+	178, 181, 182, 183, 159, 160, 162, 163, 
+	170, 188, 190, 191, 128, 129, 130, 131, 
+	128, 151, 129, 132, 135, 136, 139, 141, 
+	162, 163, 166, 172, 176, 180, 181, 183, 
+	184, 191, 133, 128, 129, 130, 134, 176, 
+	185, 189, 177, 178, 179, 186, 187, 190, 
+	191, 255, 129, 132, 255, 175, 190, 176, 
+	177, 178, 181, 184, 187, 188, 255, 129, 
+	155, 158, 255, 189, 176, 178, 179, 186, 
+	187, 190, 191, 255, 129, 255, 172, 182, 
+	171, 173, 174, 175, 176, 183, 166, 157, 
+	159, 160, 161, 162, 171, 175, 190, 176, 
+	182, 184, 191, 169, 177, 180, 146, 167, 
+	170, 182, 171, 172, 189, 190, 176, 180, 
+	176, 182, 143, 146, 178, 157, 158, 133, 
+	134, 137, 168, 169, 170, 166, 173, 165, 
+	169, 174, 178, 187, 255, 131, 132, 140, 
+	169, 174, 255, 130, 132, 128, 182, 187, 
+	255, 173, 180, 182, 255, 132, 155, 159, 
+	161, 175, 128, 163, 165, 128, 134, 136, 
+	152, 155, 161, 163, 164, 166, 170, 144, 
+	150, 132, 138, 143, 187, 191, 160, 128, 
+	129, 132, 135, 133, 134, 160, 255, 192, 
+	255, 139, 168, 128, 159, 160, 175, 176, 
+	191, 157, 128, 191, 128, 255, 176, 255, 
+	131, 137, 191, 145, 189, 135, 129, 130, 
+	132, 133, 144, 154, 176, 139, 159, 150, 
+	156, 159, 164, 167, 168, 170, 173, 145, 
+	176, 255, 139, 255, 166, 176, 171, 179, 
+	160, 161, 163, 164, 165, 166, 167, 169, 
+	171, 172, 173, 174, 175, 176, 177, 178, 
+	179, 180, 181, 182, 183, 184, 185, 186, 
+	187, 188, 189, 190, 191, 168, 170, 150, 
+	153, 155, 163, 165, 167, 169, 173, 153, 
+	155, 148, 161, 163, 255, 131, 187, 189, 
+	132, 185, 190, 255, 128, 255, 176, 255, 
+	131, 137, 191, 145, 189, 135, 129, 130, 
+	132, 133, 144, 154, 176, 139, 159, 150, 
+	156, 159, 164, 167, 168, 170, 173, 145, 
+	176, 255, 139, 255, 166, 176, 171, 179, 
+	160, 161, 163, 164, 165, 167, 169, 171, 
+	173, 174, 175, 176, 177, 179, 180, 181, 
+	182, 183, 184, 185, 186, 187, 188, 189, 
+	190, 191, 166, 170, 172, 178, 150, 153, 
+	155, 163, 165, 167, 169, 173, 153, 155, 
+	148, 161, 163, 255, 189, 132, 185, 144, 
+	152, 161, 164, 255, 188, 129, 131, 190, 
+	255, 133, 134, 137, 138, 142, 150, 152, 
+	161, 164, 255, 131, 134, 137, 138, 142, 
+	144, 146, 175, 178, 180, 182, 255, 134, 
+	138, 142, 161, 164, 255, 188, 129, 131, 
+	190, 191, 128, 132, 135, 136, 139, 141, 
+	150, 151, 162, 163, 130, 190, 191, 151, 
+	128, 130, 134, 136, 138, 141, 128, 131, 
+	190, 255, 133, 137, 142, 148, 151, 161, 
+	164, 255, 128, 132, 134, 136, 138, 141, 
+	149, 150, 162, 163, 129, 131, 190, 255, 
+	133, 137, 142, 150, 152, 161, 164, 255, 
+	130, 131, 138, 150, 143, 148, 152, 159, 
+	178, 179, 177, 179, 186, 135, 142, 177, 
+	179, 185, 187, 188, 136, 141, 181, 183, 
+	185, 152, 153, 190, 191, 177, 191, 128, 
+	132, 134, 135, 141, 151, 153, 188, 134, 
+	128, 129, 130, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 173, 183, 185, 
+	190, 150, 153, 158, 160, 177, 180, 130, 
+	141, 157, 132, 134, 157, 159, 146, 148, 
+	178, 180, 146, 147, 178, 179, 180, 255, 
+	148, 156, 158, 255, 139, 141, 169, 133, 
+	134, 160, 171, 176, 187, 151, 155, 160, 
+	162, 191, 149, 158, 165, 188, 176, 190, 
+	128, 132, 180, 255, 133, 170, 180, 255, 
+	128, 130, 161, 173, 166, 179, 164, 183, 
+	173, 144, 146, 148, 168, 178, 180, 184, 
+	185, 128, 181, 187, 191, 128, 131, 179, 
+	181, 183, 140, 141, 128, 131, 157, 179, 
+	181, 183, 144, 176, 164, 175, 177, 191, 
+	160, 191, 128, 130, 170, 175, 153, 154, 
+	153, 154, 155, 160, 162, 163, 164, 165, 
+	166, 167, 168, 169, 170, 171, 175, 175, 
+	178, 180, 189, 158, 159, 176, 177, 130, 
+	134, 139, 163, 167, 128, 129, 180, 255, 
+	134, 159, 178, 255, 166, 173, 135, 147, 
+	128, 131, 179, 255, 129, 164, 166, 255, 
+	169, 182, 131, 188, 140, 141, 176, 178, 
+	180, 183, 184, 190, 191, 129, 171, 175, 
+	181, 182, 163, 170, 172, 173, 172, 184, 
+	190, 158, 128, 143, 160, 175, 144, 145, 
+	150, 155, 157, 158, 159, 135, 139, 141, 
+	168, 171, 189, 160, 182, 186, 191, 129, 
+	131, 133, 134, 140, 143, 184, 186, 165, 
+	166, 128, 129, 130, 132, 133, 134, 135, 
+	136, 139, 140, 141, 144, 145, 146, 147, 
+	150, 151, 152, 153, 154, 156, 176, 178, 
+	128, 130, 184, 255, 135, 190, 131, 175, 
+	187, 255, 128, 130, 167, 180, 179, 128, 
+	130, 179, 255, 129, 137, 141, 255, 190, 
+	172, 183, 159, 170, 188, 128, 131, 190, 
+	191, 151, 128, 132, 135, 136, 139, 141, 
+	162, 163, 166, 172, 176, 180, 181, 191, 
+	128, 134, 176, 255, 132, 255, 175, 181, 
+	184, 255, 129, 155, 158, 255, 129, 255, 
+	171, 183, 157, 171, 175, 182, 184, 191, 
+	146, 167, 169, 182, 171, 172, 189, 190, 
+	176, 180, 176, 182, 145, 190, 143, 146, 
+	178, 157, 158, 133, 134, 137, 168, 169, 
+	170, 165, 169, 173, 178, 187, 255, 131, 
+	132, 140, 169, 174, 255, 130, 132, 128, 
+	182, 187, 255, 173, 180, 182, 255, 132, 
+	155, 159, 161, 175, 128, 163, 165, 128, 
+	134, 136, 152, 155, 161, 163, 164, 166, 
+	170, 144, 150, 132, 138, 145, 146, 151, 
+	166, 169, 139, 168, 160, 128, 129, 132, 
+	135, 133, 134, 160, 255, 192, 255, 144, 
+	145, 150, 155, 157, 158, 141, 144, 129, 
+	136, 145, 151, 152, 161, 162, 163, 164, 
+	255, 129, 188, 190, 130, 131, 191, 255, 
+	141, 151, 129, 132, 133, 134, 137, 138, 
+	142, 161, 162, 163, 164, 255, 131, 188, 
+	129, 130, 190, 255, 145, 181, 129, 130, 
+	131, 134, 135, 136, 137, 138, 139, 141, 
+	142, 175, 176, 177, 178, 255, 134, 138, 
+	141, 129, 136, 142, 161, 162, 163, 164, 
+	255, 129, 188, 130, 131, 190, 191, 128, 
+	141, 129, 132, 135, 136, 139, 140, 150, 
+	151, 162, 163, 130, 190, 191, 128, 141, 
+	151, 129, 130, 134, 136, 138, 140, 128, 
+	129, 131, 190, 255, 133, 137, 129, 132, 
+	142, 148, 151, 161, 164, 255, 129, 188, 
+	190, 191, 130, 131, 130, 134, 128, 132, 
+	135, 136, 138, 139, 140, 141, 149, 150, 
+	162, 163, 129, 190, 130, 131, 191, 255, 
+	133, 137, 141, 151, 129, 132, 142, 161, 
+	162, 163, 164, 255, 138, 143, 150, 159, 
+	144, 145, 146, 148, 152, 158, 178, 179, 
+	177, 179, 180, 186, 135, 142, 177, 179, 
+	180, 185, 187, 188, 136, 141, 181, 183, 
+	185, 152, 153, 190, 191, 191, 177, 190, 
+	128, 132, 134, 135, 141, 151, 153, 188, 
+	134, 128, 129, 130, 141, 156, 157, 158, 
+	159, 160, 162, 164, 168, 169, 170, 172, 
+	173, 174, 175, 176, 179, 183, 177, 173, 
+	183, 185, 186, 187, 188, 189, 190, 150, 
+	151, 152, 153, 158, 160, 177, 180, 130, 
+	132, 141, 157, 133, 134, 157, 159, 146, 
+	148, 178, 180, 146, 147, 178, 179, 182, 
+	180, 189, 190, 255, 134, 157, 137, 147, 
+	148, 255, 139, 141, 169, 133, 134, 178, 
+	160, 162, 163, 166, 167, 168, 169, 171, 
+	176, 184, 185, 187, 155, 151, 152, 153, 
+	154, 150, 160, 162, 191, 149, 151, 152, 
+	158, 165, 172, 173, 178, 179, 188, 176, 
+	190, 132, 181, 187, 128, 131, 180, 188, 
+	189, 255, 130, 133, 170, 171, 179, 180, 
+	255, 130, 161, 170, 128, 129, 162, 165, 
+	166, 167, 168, 173, 167, 173, 166, 169, 
+	170, 174, 175, 177, 178, 179, 164, 171, 
+	172, 179, 180, 181, 182, 183, 161, 173, 
+	180, 144, 146, 148, 168, 178, 179, 184, 
+	185, 128, 181, 187, 191, 128, 131, 179, 
+	181, 183, 140, 141, 144, 176, 175, 177, 
+	191, 160, 191, 128, 130, 170, 175, 153, 
+	154, 153, 154, 155, 160, 162, 163, 164, 
+	165, 166, 167, 168, 169, 170, 171, 175, 
+	175, 178, 180, 189, 158, 159, 176, 177, 
+	130, 134, 139, 167, 163, 164, 165, 166, 
+	132, 133, 134, 159, 160, 177, 178, 255, 
+	166, 173, 135, 145, 146, 147, 131, 179, 
+	188, 128, 130, 180, 181, 182, 185, 186, 
+	255, 165, 129, 255, 169, 174, 175, 176, 
+	177, 178, 179, 180, 181, 182, 131, 140, 
+	141, 188, 176, 178, 180, 183, 184, 190, 
+	191, 129, 171, 181, 182, 172, 173, 174, 
+	175, 165, 168, 172, 173, 163, 170, 172, 
+	184, 190, 158, 128, 143, 160, 175, 144, 
+	145, 150, 155, 157, 158, 159, 135, 139, 
+	141, 168, 171, 189, 160, 182, 186, 191, 
+	129, 131, 133, 134, 140, 143, 184, 186, 
+	165, 166, 128, 129, 130, 132, 133, 134, 
+	135, 136, 139, 140, 141, 144, 145, 146, 
+	147, 150, 151, 152, 153, 154, 156, 176, 
+	178, 129, 128, 130, 184, 255, 135, 190, 
+	130, 131, 175, 176, 178, 183, 184, 187, 
+	255, 172, 128, 130, 167, 180, 179, 130, 
+	128, 129, 179, 181, 182, 190, 191, 255, 
+	129, 137, 138, 140, 141, 255, 180, 190, 
+	172, 174, 175, 177, 178, 181, 182, 183, 
+	159, 160, 162, 163, 170, 188, 190, 191, 
+	128, 129, 130, 131, 128, 151, 129, 132, 
+	135, 136, 139, 141, 162, 163, 166, 172, 
+	176, 180, 181, 183, 184, 191, 133, 128, 
+	129, 130, 134, 176, 185, 189, 177, 178, 
+	179, 186, 187, 190, 191, 255, 129, 132, 
+	255, 175, 190, 176, 177, 178, 181, 184, 
+	187, 188, 255, 129, 155, 158, 255, 189, 
+	176, 178, 179, 186, 187, 190, 191, 255, 
+	129, 255, 172, 182, 171, 173, 174, 175, 
+	176, 183, 166, 157, 159, 160, 161, 162, 
+	171, 175, 190, 176, 182, 184, 191, 169, 
+	177, 180, 146, 167, 170, 182, 171, 172, 
+	189, 190, 176, 180, 176, 182, 143, 146, 
+	178, 157, 158, 133, 134, 137, 168, 169, 
+	170, 166, 173, 165, 169, 174, 178, 187, 
+	255, 131, 132, 140, 169, 174, 255, 130, 
+	132, 128, 182, 187, 255, 173, 180, 182, 
+	255, 132, 155, 159, 161, 175, 128, 163, 
+	165, 128, 134, 136, 152, 155, 161, 163, 
+	164, 166, 170, 144, 150, 132, 138, 143, 
+	187, 191, 160, 128, 129, 132, 135, 133, 
+	134, 160, 255, 192, 255, 185, 128, 191, 
+	128, 137, 138, 141, 142, 191, 128, 191, 
+	165, 177, 178, 179, 180, 181, 182, 184, 
+	185, 186, 187, 188, 189, 191, 128, 175, 
+	176, 190, 192, 255, 128, 159, 160, 188, 
+	189, 191, 128, 156, 184, 129, 255, 148, 
+	176, 140, 168, 132, 160, 188, 152, 180, 
+	144, 172, 136, 164, 192, 255, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 160, 161, 162, 164, 165, 166, 167, 
+	168, 169, 171, 172, 173, 174, 175, 176, 
+	178, 179, 180, 181, 182, 183, 185, 186, 
+	187, 188, 189, 190, 128, 191, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 160, 161, 162, 164, 165, 166, 167, 
+	168, 169, 171, 172, 173, 174, 175, 176, 
+	178, 179, 180, 181, 182, 183, 185, 186, 
+	187, 188, 189, 190, 128, 191, 129, 130, 
+	131, 132, 133, 134, 136, 137, 138, 139, 
+	140, 141, 143, 144, 145, 146, 147, 148, 
+	150, 151, 152, 153, 154, 155, 157, 158, 
+	159, 160, 191, 128, 156, 161, 190, 192, 
+	255, 136, 164, 175, 176, 255, 135, 138, 
+	139, 187, 188, 191, 192, 255, 0, 127, 
+	192, 255, 187, 191, 128, 190, 191, 128, 
+	190, 188, 128, 175, 176, 189, 190, 191, 
+	145, 155, 157, 159, 128, 191, 130, 135, 
+	128, 191, 189, 128, 191, 128, 129, 130, 
+	131, 132, 191, 178, 128, 191, 128, 159, 
+	160, 163, 164, 191, 133, 128, 191, 128, 
+	178, 179, 186, 187, 191, 135, 142, 143, 
+	145, 146, 149, 150, 153, 154, 155, 164, 
+	128, 191, 128, 165, 166, 191, 128, 255, 
+	176, 255, 131, 137, 191, 145, 189, 135, 
+	129, 130, 132, 133, 144, 154, 176, 139, 
+	159, 150, 156, 159, 164, 167, 168, 170, 
+	173, 145, 176, 255, 139, 255, 166, 176, 
+	171, 179, 160, 161, 163, 164, 165, 167, 
+	169, 171, 173, 174, 175, 176, 177, 179, 
+	180, 181, 182, 183, 184, 185, 186, 187, 
+	188, 189, 190, 191, 166, 170, 172, 178, 
+	150, 153, 155, 163, 165, 167, 169, 173, 
+	153, 155, 148, 161, 163, 255, 189, 132, 
+	185, 144, 152, 161, 164, 255, 188, 129, 
+	131, 190, 255, 133, 134, 137, 138, 142, 
+	150, 152, 161, 164, 255, 131, 134, 137, 
+	138, 142, 144, 146, 175, 178, 180, 182, 
+	255, 134, 138, 142, 161, 164, 255, 188, 
+	129, 131, 190, 191, 128, 132, 135, 136, 
+	139, 141, 150, 151, 162, 163, 130, 190, 
+	191, 151, 128, 130, 134, 136, 138, 141, 
+	128, 131, 190, 255, 133, 137, 142, 148, 
+	151, 161, 164, 255, 128, 132, 134, 136, 
+	138, 141, 149, 150, 162, 163, 129, 131, 
+	190, 255, 133, 137, 142, 150, 152, 161, 
+	164, 255, 130, 131, 138, 150, 143, 148, 
+	152, 159, 178, 179, 177, 179, 186, 135, 
+	142, 177, 179, 185, 187, 188, 136, 141, 
+	181, 183, 185, 152, 153, 190, 191, 177, 
+	191, 128, 132, 134, 135, 141, 151, 153, 
+	188, 134, 128, 129, 130, 141, 156, 157, 
+	158, 159, 160, 162, 164, 168, 169, 170, 
+	172, 173, 174, 175, 176, 179, 183, 173, 
+	183, 185, 190, 150, 153, 158, 160, 177, 
+	180, 130, 141, 157, 132, 134, 157, 159, 
+	146, 148, 178, 180, 146, 147, 178, 179, 
+	180, 255, 148, 156, 158, 255, 139, 141, 
+	169, 133, 134, 160, 171, 176, 187, 151, 
+	155, 160, 162, 191, 149, 158, 165, 188, 
+	176, 190, 128, 132, 180, 255, 133, 170, 
+	180, 255, 128, 130, 161, 173, 166, 179, 
+	164, 183, 173, 144, 146, 148, 168, 178, 
+	180, 184, 185, 128, 181, 187, 191, 128, 
+	131, 179, 181, 183, 140, 141, 128, 131, 
+	157, 179, 181, 183, 144, 176, 164, 175, 
+	177, 191, 160, 191, 128, 130, 170, 175, 
+	153, 154, 153, 154, 155, 160, 162, 163, 
+	164, 165, 166, 167, 168, 169, 170, 171, 
+	175, 175, 178, 180, 189, 158, 159, 176, 
+	177, 130, 134, 139, 163, 167, 128, 129, 
+	180, 255, 134, 159, 178, 255, 166, 173, 
+	135, 147, 128, 131, 179, 255, 129, 164, 
+	166, 255, 169, 182, 131, 188, 140, 141, 
+	176, 178, 180, 183, 184, 190, 191, 129, 
+	171, 175, 181, 182, 163, 170, 172, 173, 
+	172, 184, 190, 158, 128, 143, 160, 175, 
+	144, 145, 150, 155, 157, 158, 159, 135, 
+	139, 141, 168, 171, 189, 160, 182, 186, 
+	191, 129, 131, 133, 134, 140, 143, 184, 
+	186, 165, 166, 128, 129, 130, 132, 133, 
+	134, 135, 136, 139, 140, 141, 144, 145, 
+	146, 147, 150, 151, 152, 153, 154, 156, 
+	176, 178, 128, 130, 184, 255, 135, 190, 
+	131, 175, 187, 255, 128, 130, 167, 180, 
+	179, 128, 130, 179, 255, 129, 137, 141, 
+	255, 190, 172, 183, 159, 170, 188, 128, 
+	131, 190, 191, 151, 128, 132, 135, 136, 
+	139, 141, 162, 163, 166, 172, 176, 180, 
+	181, 191, 128, 134, 176, 255, 132, 255, 
+	175, 181, 184, 255, 129, 155, 158, 255, 
+	129, 255, 171, 183, 157, 171, 175, 182, 
+	184, 191, 146, 167, 169, 182, 171, 172, 
+	189, 190, 176, 180, 176, 182, 145, 190, 
+	143, 146, 178, 157, 158, 133, 134, 137, 
+	168, 169, 170, 165, 169, 173, 178, 187, 
+	255, 131, 132, 140, 169, 174, 255, 130, 
+	132, 128, 182, 187, 255, 173, 180, 182, 
+	255, 132, 155, 159, 161, 175, 128, 163, 
+	165, 128, 134, 136, 152, 155, 161, 163, 
+	164, 166, 170, 144, 150, 132, 138, 145, 
+	146, 151, 166, 169, 128, 255, 176, 255, 
+	131, 137, 191, 145, 189, 135, 129, 130, 
+	132, 133, 144, 154, 176, 139, 159, 150, 
+	156, 159, 164, 167, 168, 170, 173, 145, 
+	176, 255, 139, 255, 166, 176, 171, 179, 
+	160, 161, 163, 164, 165, 166, 167, 169, 
+	171, 172, 173, 174, 175, 176, 177, 178, 
+	179, 180, 181, 182, 183, 184, 185, 186, 
+	187, 188, 189, 190, 191, 168, 170, 150, 
+	153, 155, 163, 165, 167, 169, 173, 153, 
+	155, 148, 161, 163, 255, 131, 187, 189, 
+	132, 185, 190, 255, 141, 144, 129, 136, 
+	145, 151, 152, 161, 162, 163, 164, 255, 
+	129, 188, 190, 130, 131, 191, 255, 141, 
+	151, 129, 132, 133, 134, 137, 138, 142, 
+	161, 162, 163, 164, 255, 131, 188, 129, 
+	130, 190, 255, 145, 181, 129, 130, 131, 
+	134, 135, 136, 137, 138, 139, 141, 142, 
+	175, 176, 177, 178, 255, 134, 138, 141, 
+	129, 136, 142, 161, 162, 163, 164, 255, 
+	129, 188, 130, 131, 190, 191, 128, 141, 
+	129, 132, 135, 136, 139, 140, 150, 151, 
+	162, 163, 130, 190, 191, 128, 141, 151, 
+	129, 130, 134, 136, 138, 140, 128, 129, 
+	131, 190, 255, 133, 137, 129, 132, 142, 
+	148, 151, 161, 164, 255, 129, 188, 190, 
+	191, 130, 131, 130, 134, 128, 132, 135, 
+	136, 138, 139, 140, 141, 149, 150, 162, 
+	163, 129, 190, 130, 131, 191, 255, 133, 
+	137, 141, 151, 129, 132, 142, 161, 162, 
+	163, 164, 255, 138, 143, 150, 159, 144, 
+	145, 146, 148, 152, 158, 178, 179, 177, 
+	179, 180, 186, 135, 142, 177, 179, 180, 
+	185, 187, 188, 136, 141, 181, 183, 185, 
+	152, 153, 190, 191, 191, 177, 190, 128, 
+	132, 134, 135, 141, 151, 153, 188, 134, 
+	128, 129, 130, 141, 156, 157, 158, 159, 
+	160, 162, 164, 168, 169, 170, 172, 173, 
+	174, 175, 176, 179, 183, 177, 173, 183, 
+	185, 186, 187, 188, 189, 190, 150, 151, 
+	152, 153, 158, 160, 177, 180, 130, 132, 
+	141, 157, 133, 134, 157, 159, 146, 148, 
+	178, 180, 146, 147, 178, 179, 182, 180, 
+	189, 190, 255, 134, 157, 137, 147, 148, 
+	255, 139, 141, 169, 133, 134, 178, 160, 
+	162, 163, 166, 167, 168, 169, 171, 176, 
+	184, 185, 187, 155, 151, 152, 153, 154, 
+	150, 160, 162, 191, 149, 151, 152, 158, 
+	165, 172, 173, 178, 179, 188, 176, 190, 
+	132, 181, 187, 128, 131, 180, 188, 189, 
+	255, 130, 133, 170, 171, 179, 180, 255, 
+	130, 161, 170, 128, 129, 162, 165, 166, 
+	167, 168, 173, 167, 173, 166, 169, 170, 
+	174, 175, 177, 178, 179, 164, 171, 172, 
+	179, 180, 181, 182, 183, 161, 173, 180, 
+	144, 146, 148, 168, 178, 179, 184, 185, 
+	128, 181, 187, 191, 128, 131, 179, 181, 
+	183, 140, 141, 144, 176, 175, 177, 191, 
+	160, 191, 128, 130, 170, 175, 153, 154, 
+	153, 154, 155, 160, 162, 163, 164, 165, 
+	166, 167, 168, 169, 170, 171, 175, 175, 
+	178, 180, 189, 158, 159, 176, 177, 130, 
+	134, 139, 167, 163, 164, 165, 166, 132, 
+	133, 134, 159, 160, 177, 178, 255, 166, 
+	173, 135, 145, 146, 147, 131, 179, 188, 
+	128, 130, 180, 181, 182, 185, 186, 255, 
+	165, 129, 255, 169, 174, 175, 176, 177, 
+	178, 179, 180, 181, 182, 131, 140, 141, 
+	188, 176, 178, 180, 183, 184, 190, 191, 
+	129, 171, 181, 182, 172, 173, 174, 175, 
+	165, 168, 172, 173, 163, 170, 172, 184, 
+	190, 158, 128, 143, 160, 175, 144, 145, 
+	150, 155, 157, 158, 159, 135, 139, 141, 
+	168, 171, 189, 160, 182, 186, 191, 129, 
+	131, 133, 134, 140, 143, 184, 186, 165, 
+	166, 128, 129, 130, 132, 133, 134, 135, 
+	136, 139, 140, 141, 144, 145, 146, 147, 
+	150, 151, 152, 153, 154, 156, 176, 178, 
+	129, 128, 130, 184, 255, 135, 190, 130, 
+	131, 175, 176, 178, 183, 184, 187, 255, 
+	172, 128, 130, 167, 180, 179, 130, 128, 
+	129, 179, 181, 182, 190, 191, 255, 129, 
+	137, 138, 140, 141, 255, 180, 190, 172, 
+	174, 175, 177, 178, 181, 182, 183, 159, 
+	160, 162, 163, 170, 188, 190, 191, 128, 
+	129, 130, 131, 128, 151, 129, 132, 135, 
+	136, 139, 141, 162, 163, 166, 172, 176, 
+	180, 181, 183, 184, 191, 133, 128, 129, 
+	130, 134, 176, 185, 189, 177, 178, 179, 
+	186, 187, 190, 191, 255, 129, 132, 255, 
+	175, 190, 176, 177, 178, 181, 184, 187, 
+	188, 255, 129, 155, 158, 255, 189, 176, 
+	178, 179, 186, 187, 190, 191, 255, 129, 
+	255, 172, 182, 171, 173, 174, 175, 176, 
+	183, 166, 157, 159, 160, 161, 162, 171, 
+	175, 190, 176, 182, 184, 191, 169, 177, 
+	180, 146, 167, 170, 182, 171, 172, 189, 
+	190, 176, 180, 176, 182, 143, 146, 178, 
+	157, 158, 133, 134, 137, 168, 169, 170, 
+	166, 173, 165, 169, 174, 178, 187, 255, 
+	131, 132, 140, 169, 174, 255, 130, 132, 
+	128, 182, 187, 255, 173, 180, 182, 255, 
+	132, 155, 159, 161, 175, 128, 163, 165, 
+	128, 134, 136, 152, 155, 161, 163, 164, 
+	166, 170, 144, 150, 132, 138, 143, 187, 
+	191, 160, 128, 129, 132, 135, 133, 134, 
+	160, 255, 192, 255, 139, 168, 160, 128, 
+	129, 132, 135, 133, 134, 160, 255, 192, 
+	255, 144, 145, 150, 155, 157, 158, 144, 
+	145, 150, 155, 157, 158, 159, 135, 166, 
+	191, 133, 128, 191, 128, 130, 131, 132, 
+	133, 137, 138, 139, 140, 191, 174, 188, 
+	128, 129, 130, 131, 132, 133, 134, 144, 
+	145, 165, 166, 169, 170, 175, 176, 184, 
+	185, 191, 128, 132, 170, 129, 135, 136, 
+	191, 181, 186, 128, 191, 144, 128, 148, 
+	149, 150, 151, 191, 128, 132, 133, 135, 
+	136, 138, 139, 143, 144, 191, 163, 128, 
+	179, 180, 182, 183, 191, 128, 129, 191, 
+	166, 176, 191, 128, 151, 152, 158, 159, 
+	178, 179, 185, 186, 187, 188, 190, 128, 
+	191, 160, 128, 191, 128, 130, 131, 135, 
+	191, 129, 134, 136, 190, 128, 159, 160, 
+	191, 128, 175, 176, 255, 10, 13, 127, 
+	194, 216, 219, 220, 224, 225, 226, 234, 
+	235, 236, 237, 239, 240, 243, 0, 31, 
+	128, 191, 192, 223, 227, 238, 241, 247, 
+	248, 255, 204, 205, 210, 214, 215, 216, 
+	217, 219, 220, 221, 222, 223, 224, 225, 
+	226, 227, 234, 239, 240, 243, 204, 205, 
+	210, 214, 215, 216, 217, 219, 220, 221, 
+	222, 223, 224, 225, 226, 227, 234, 239, 
+	240, 243, 204, 205, 210, 214, 215, 216, 
+	217, 219, 220, 221, 222, 223, 224, 225, 
+	226, 227, 234, 239, 240, 243, 194, 216, 
+	219, 220, 224, 225, 226, 234, 235, 236, 
+	237, 239, 240, 243, 32, 126, 192, 223, 
+	227, 238, 241, 247, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 235, 236, 237, 239, 240, 243, 204, 
+	205, 210, 214, 215, 216, 217, 219, 220, 
+	221, 222, 223, 224, 225, 226, 227, 234, 
+	237, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 237, 239, 240, 
+	243, 204, 205, 210, 214, 215, 216, 217, 
+	219, 220, 221, 222, 223, 224, 225, 226, 
+	227, 234, 237, 239, 240, 243, 204, 205, 
+	210, 214, 215, 216, 217, 219, 220, 221, 
+	222, 223, 224, 225, 226, 227, 234, 239, 
+	240, 243, 204, 205, 210, 214, 215, 216, 
+	217, 219, 220, 221, 222, 223, 224, 225, 
+	226, 227, 234, 235, 236, 237, 239, 240, 
+	243, 204, 205, 210, 214, 215, 216, 217, 
+	219, 220, 221, 222, 223, 224, 225, 226, 
+	227, 234, 239, 240, 243, 204, 205, 210, 
+	214, 215, 216, 217, 219, 220, 221, 222, 
+	223, 224, 225, 226, 227, 234, 239, 240, 
+	243, 204, 205, 210, 214, 215, 216, 217, 
+	219, 220, 221, 222, 223, 224, 225, 226, 
+	227, 234, 239, 240, 243, 204, 205, 210, 
+	214, 215, 216, 217, 219, 220, 221, 222, 
+	223, 224, 225, 226, 227, 234, 237, 239, 
+	240, 243, 204, 205, 210, 214, 215, 216, 
+	217, 219, 220, 221, 222, 223, 224, 225, 
+	226, 227, 234, 237, 239, 240, 243, 204, 
+	205, 210, 214, 215, 216, 217, 219, 220, 
+	221, 222, 223, 224, 225, 226, 227, 234, 
+	237, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 204, 205, 210, 214, 
+	215, 216, 217, 219, 220, 221, 222, 223, 
+	224, 225, 226, 227, 234, 239, 240, 243, 
+	204, 205, 210, 214, 215, 216, 217, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	234, 239, 240, 243, 
+}
+
+var _graphclust_single_lengths []byte = []byte{
+	0, 1, 0, 0, 0, 1, 1, 0, 
+	1, 0, 1, 0, 0, 0, 26, 0, 
+	0, 0, 1, 1, 1, 0, 0, 2, 
+	1, 0, 1, 1, 0, 2, 0, 0, 
+	2, 0, 2, 1, 0, 1, 0, 3, 
+	0, 0, 1, 21, 0, 0, 3, 0, 
+	0, 0, 0, 0, 0, 1, 0, 0, 
+	3, 0, 0, 0, 0, 0, 0, 1, 
+	0, 5, 2, 6, 0, 1, 0, 1, 
+	0, 2, 0, 0, 15, 0, 0, 0, 
+	3, 0, 0, 0, 0, 0, 0, 0, 
+	2, 1, 1, 0, 3, 1, 0, 7, 
+	5, 1, 1, 0, 1, 0, 23, 0, 
+	0, 0, 0, 1, 0, 0, 1, 0, 
+	1, 1, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 4, 0, 0, 
+	0, 0, 1, 0, 6, 0, 0, 0, 
+	0, 0, 1, 3, 0, 0, 0, 3, 
+	0, 0, 0, 0, 1, 1, 0, 1, 
+	0, 1, 0, 0, 0, 29, 0, 0, 
+	0, 3, 2, 3, 2, 2, 2, 3, 
+	2, 2, 3, 3, 1, 2, 4, 2, 
+	2, 4, 4, 2, 0, 2, 0, 3, 
+	1, 0, 1, 21, 1, 0, 4, 0, 
+	0, 0, 1, 2, 0, 1, 1, 1, 
+	4, 0, 3, 1, 3, 2, 0, 3, 
+	0, 5, 2, 0, 0, 1, 0, 2, 
+	0, 0, 15, 0, 0, 0, 4, 0, 
+	0, 0, 3, 1, 0, 4, 1, 4, 
+	4, 3, 1, 0, 7, 5, 1, 1, 
+	0, 1, 0, 23, 1, 0, 1, 1, 
+	1, 1, 0, 2, 1, 3, 2, 0, 
+	1, 3, 1, 2, 0, 1, 0, 2, 
+	1, 2, 3, 4, 0, 0, 0, 1, 
+	0, 6, 2, 0, 0, 0, 0, 1, 
+	3, 0, 0, 0, 1, 0, 1, 4, 
+	0, 0, 0, 1, 1, 1, 4, 0, 
+	0, 0, 6, 0, 1, 1, 0, 0, 
+	0, 1, 1, 0, 1, 0, 1, 0, 
+	0, 0, 26, 0, 0, 0, 1, 1, 
+	1, 0, 0, 2, 1, 0, 1, 1, 
+	0, 2, 0, 0, 2, 0, 2, 1, 
+	0, 1, 0, 3, 0, 0, 1, 21, 
+	0, 0, 3, 0, 0, 0, 0, 0, 
+	0, 1, 0, 0, 3, 0, 0, 0, 
+	0, 0, 0, 1, 0, 5, 2, 6, 
+	0, 1, 0, 1, 0, 2, 0, 0, 
+	15, 0, 0, 0, 3, 0, 0, 0, 
+	0, 0, 0, 0, 2, 1, 1, 0, 
+	3, 1, 0, 7, 5, 1, 1, 0, 
+	1, 0, 23, 0, 0, 0, 0, 1, 
+	0, 0, 1, 0, 1, 1, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 4, 0, 0, 0, 0, 1, 0, 
+	6, 0, 0, 0, 0, 0, 1, 3, 
+	0, 0, 0, 3, 0, 0, 0, 0, 
+	1, 1, 0, 1, 0, 1, 0, 0, 
+	0, 29, 0, 0, 0, 3, 2, 3, 
+	2, 2, 2, 3, 2, 2, 3, 3, 
+	1, 2, 4, 2, 2, 4, 4, 2, 
+	0, 2, 0, 3, 1, 0, 1, 21, 
+	1, 0, 4, 0, 0, 0, 1, 2, 
+	0, 1, 1, 1, 4, 0, 3, 1, 
+	3, 2, 0, 3, 0, 5, 2, 0, 
+	0, 1, 0, 2, 0, 0, 15, 0, 
+	0, 0, 4, 0, 0, 0, 3, 1, 
+	0, 4, 1, 4, 4, 3, 1, 0, 
+	7, 5, 1, 1, 0, 1, 0, 23, 
+	1, 0, 1, 1, 1, 1, 0, 2, 
+	1, 3, 2, 0, 1, 3, 1, 2, 
+	0, 1, 0, 2, 1, 2, 3, 4, 
+	0, 0, 0, 1, 0, 6, 2, 0, 
+	0, 0, 0, 1, 3, 0, 0, 0, 
+	1, 0, 1, 4, 0, 0, 0, 1, 
+	1, 1, 4, 0, 0, 0, 6, 0, 
+	0, 0, 1, 1, 2, 1, 1, 5, 
+	0, 24, 0, 24, 0, 0, 23, 0, 
+	0, 1, 0, 2, 0, 0, 0, 28, 
+	0, 3, 23, 2, 0, 2, 2, 3, 
+	2, 2, 2, 0, 54, 54, 27, 1, 
+	0, 5, 2, 0, 1, 1, 0, 0, 
+	14, 0, 3, 2, 2, 3, 2, 2, 
+	2, 54, 54, 27, 1, 0, 2, 0, 
+	1, 4, 2, 1, 0, 1, 0, 1, 
+	0, 11, 0, 7, 1, 0, 1, 0, 
+	2, 3, 2, 1, 0, 1, 1, 3, 
+	0, 1, 3, 0, 1, 1, 2, 1, 
+	1, 5, 0, 0, 0, 0, 1, 1, 
+	0, 1, 0, 1, 0, 0, 0, 26, 
+	0, 0, 0, 1, 1, 1, 0, 0, 
+	2, 1, 0, 1, 1, 0, 2, 0, 
+	0, 2, 0, 2, 1, 0, 1, 0, 
+	3, 0, 0, 1, 21, 0, 0, 3, 
+	0, 0, 0, 0, 0, 0, 1, 0, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	1, 0, 5, 2, 6, 0, 1, 0, 
+	1, 0, 2, 0, 0, 15, 0, 0, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	0, 2, 1, 1, 0, 3, 1, 0, 
+	7, 5, 1, 1, 0, 1, 0, 23, 
+	0, 0, 0, 0, 1, 0, 0, 1, 
+	0, 1, 1, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 4, 0, 
+	0, 0, 0, 1, 0, 6, 0, 0, 
+	0, 0, 0, 1, 3, 0, 0, 0, 
+	3, 0, 0, 0, 0, 1, 1, 0, 
+	1, 0, 1, 0, 0, 0, 29, 0, 
+	0, 0, 3, 2, 3, 2, 2, 2, 
+	3, 2, 2, 3, 3, 1, 2, 4, 
+	2, 2, 4, 4, 2, 0, 2, 0, 
+	3, 1, 0, 1, 21, 1, 0, 4, 
+	0, 0, 0, 1, 2, 0, 1, 1, 
+	1, 4, 0, 3, 1, 3, 2, 0, 
+	3, 0, 5, 2, 0, 0, 1, 0, 
+	2, 0, 0, 15, 0, 0, 0, 4, 
+	0, 0, 0, 3, 1, 0, 4, 1, 
+	4, 4, 3, 1, 0, 7, 5, 1, 
+	1, 0, 1, 0, 23, 1, 0, 1, 
+	1, 1, 1, 0, 2, 1, 3, 2, 
+	0, 1, 3, 1, 2, 0, 1, 0, 
+	2, 1, 2, 3, 4, 0, 0, 0, 
+	1, 0, 6, 2, 0, 0, 0, 0, 
+	1, 3, 0, 0, 0, 1, 0, 1, 
+	4, 0, 0, 0, 1, 1, 1, 4, 
+	0, 0, 0, 6, 24, 0, 24, 0, 
+	0, 23, 0, 0, 1, 0, 2, 0, 
+	0, 0, 28, 0, 3, 23, 2, 0, 
+	2, 2, 3, 2, 2, 2, 0, 54, 
+	54, 27, 1, 1, 5, 2, 0, 0, 
+	0, 1, 1, 0, 1, 0, 1, 0, 
+	0, 0, 26, 0, 0, 0, 1, 1, 
+	1, 0, 0, 2, 1, 0, 1, 1, 
+	0, 2, 0, 0, 2, 0, 2, 1, 
+	0, 1, 0, 3, 0, 0, 1, 21, 
+	0, 0, 3, 0, 0, 0, 0, 0, 
+	0, 1, 0, 0, 3, 0, 0, 0, 
+	0, 0, 0, 1, 0, 5, 2, 0, 
+	0, 1, 0, 2, 0, 0, 15, 0, 
+	0, 0, 3, 0, 0, 0, 0, 0, 
+	0, 0, 2, 1, 1, 0, 3, 1, 
+	0, 6, 5, 1, 1, 0, 1, 0, 
+	23, 0, 0, 0, 0, 1, 0, 0, 
+	1, 0, 1, 1, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 4, 
+	0, 0, 0, 0, 1, 0, 6, 0, 
+	0, 0, 0, 0, 1, 3, 0, 0, 
+	0, 1, 4, 0, 0, 0, 6, 1, 
+	7, 3, 0, 0, 0, 0, 1, 1, 
+	0, 1, 0, 1, 0, 0, 0, 29, 
+	0, 0, 0, 3, 2, 3, 2, 2, 
+	2, 3, 2, 2, 3, 3, 1, 2, 
+	4, 2, 2, 4, 4, 2, 0, 2, 
+	0, 3, 1, 0, 1, 21, 1, 0, 
+	4, 0, 0, 0, 1, 2, 0, 1, 
+	1, 1, 4, 0, 3, 1, 3, 2, 
+	0, 3, 0, 5, 2, 0, 0, 1, 
+	0, 2, 0, 0, 15, 0, 0, 0, 
+	4, 0, 0, 0, 3, 1, 0, 4, 
+	1, 4, 4, 3, 1, 0, 7, 5, 
+	1, 1, 0, 1, 0, 23, 1, 0, 
+	1, 1, 1, 1, 0, 2, 1, 3, 
+	2, 0, 1, 3, 1, 2, 0, 1, 
+	0, 2, 1, 2, 3, 4, 0, 0, 
+	0, 1, 0, 6, 2, 0, 0, 0, 
+	0, 1, 3, 0, 0, 0, 1, 0, 
+	1, 4, 0, 0, 0, 1, 1, 0, 
+	1, 0, 0, 0, 1, 1, 0, 1, 
+	0, 1, 0, 0, 0, 29, 0, 0, 
+	0, 3, 0, 0, 0, 1, 1, 0, 
+	1, 0, 1, 0, 0, 0, 26, 0, 
+	0, 0, 1, 1, 1, 0, 0, 2, 
+	1, 0, 1, 1, 0, 2, 0, 0, 
+	2, 0, 2, 1, 0, 1, 0, 3, 
+	0, 0, 1, 21, 0, 0, 3, 0, 
+	0, 0, 0, 0, 0, 1, 0, 0, 
+	3, 0, 0, 0, 0, 0, 0, 1, 
+	0, 5, 2, 6, 0, 1, 0, 1, 
+	0, 2, 0, 0, 15, 0, 0, 0, 
+	3, 0, 0, 0, 0, 0, 0, 0, 
+	2, 1, 1, 0, 3, 1, 0, 7, 
+	5, 1, 1, 0, 1, 0, 23, 0, 
+	0, 0, 0, 1, 0, 0, 1, 0, 
+	1, 1, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 4, 0, 0, 
+	0, 0, 1, 0, 6, 0, 0, 0, 
+	0, 0, 1, 3, 0, 0, 0, 3, 
+	0, 1, 1, 1, 4, 0, 0, 0, 
+	6, 2, 3, 2, 2, 2, 3, 2, 
+	2, 3, 3, 1, 2, 4, 2, 2, 
+	4, 4, 2, 0, 2, 0, 3, 1, 
+	0, 1, 21, 1, 0, 4, 0, 0, 
+	0, 1, 2, 0, 1, 1, 1, 4, 
+	0, 3, 1, 3, 2, 0, 3, 0, 
+	5, 2, 0, 0, 1, 0, 2, 0, 
+	0, 15, 0, 0, 0, 4, 0, 0, 
+	0, 3, 1, 0, 4, 1, 4, 4, 
+	3, 1, 0, 7, 5, 1, 1, 0, 
+	1, 0, 23, 1, 0, 1, 1, 1, 
+	1, 0, 2, 1, 3, 2, 0, 1, 
+	3, 1, 2, 0, 1, 0, 2, 1, 
+	2, 3, 4, 0, 0, 0, 1, 0, 
+	6, 2, 0, 0, 0, 0, 1, 3, 
+	0, 0, 0, 1, 0, 1, 4, 0, 
+	0, 0, 1, 0, 0, 14, 0, 3, 
+	2, 2, 3, 2, 2, 2, 54, 54, 
+	29, 1, 0, 0, 0, 0, 2, 1, 
+	1, 4, 2, 1, 0, 1, 0, 1, 
+	0, 11, 0, 0, 0, 0, 1, 1, 
+	0, 1, 0, 1, 0, 0, 0, 26, 
+	0, 0, 0, 1, 1, 1, 0, 0, 
+	2, 1, 0, 1, 1, 0, 2, 0, 
+	0, 2, 0, 2, 1, 0, 1, 0, 
+	3, 0, 0, 1, 21, 0, 0, 3, 
+	0, 0, 0, 0, 0, 0, 1, 0, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	1, 0, 5, 2, 6, 0, 1, 0, 
+	1, 0, 2, 0, 0, 15, 0, 0, 
+	0, 3, 0, 0, 0, 0, 0, 0, 
+	0, 2, 1, 1, 0, 3, 1, 0, 
+	7, 5, 1, 1, 0, 1, 0, 23, 
+	0, 0, 0, 0, 1, 0, 0, 1, 
+	0, 1, 1, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 4, 0, 
+	0, 0, 0, 1, 0, 6, 0, 0, 
+	0, 0, 0, 1, 3, 0, 0, 0, 
+	3, 0, 0, 0, 0, 1, 1, 0, 
+	1, 0, 1, 0, 0, 0, 29, 0, 
+	0, 0, 3, 2, 3, 2, 2, 2, 
+	3, 2, 2, 3, 3, 1, 2, 4, 
+	2, 2, 4, 4, 2, 0, 2, 0, 
+	3, 1, 0, 1, 21, 1, 0, 4, 
+	0, 0, 0, 1, 2, 0, 1, 1, 
+	1, 4, 0, 3, 1, 3, 2, 0, 
+	3, 0, 5, 2, 0, 0, 1, 0, 
+	2, 0, 0, 15, 0, 0, 0, 4, 
+	0, 0, 0, 3, 1, 0, 4, 1, 
+	4, 4, 3, 1, 0, 7, 5, 1, 
+	1, 0, 1, 0, 23, 1, 0, 1, 
+	1, 1, 1, 0, 2, 1, 3, 2, 
+	0, 1, 3, 1, 2, 0, 1, 0, 
+	2, 1, 2, 3, 4, 0, 0, 0, 
+	1, 0, 6, 2, 0, 0, 0, 0, 
+	1, 3, 0, 0, 0, 1, 0, 1, 
+	4, 0, 0, 0, 1, 1, 1, 4, 
+	0, 0, 0, 6, 7, 1, 0, 1, 
+	0, 2, 3, 2, 1, 0, 1, 1, 
+	3, 0, 1, 5, 0, 0, 17, 20, 
+	20, 20, 14, 20, 20, 20, 23, 21, 
+	21, 21, 20, 23, 20, 20, 20, 21, 
+	21, 21, 20, 20, 20, 20, 20, 20, 
+	20, 20, 20, 20, 
+}
+
+var _graphclust_range_lengths []byte = []byte{
+	0, 0, 1, 1, 1, 1, 2, 1, 
+	1, 4, 1, 1, 1, 1, 2, 4, 
+	1, 2, 1, 2, 2, 5, 6, 2, 
+	2, 5, 1, 3, 2, 3, 5, 2, 
+	3, 1, 3, 1, 1, 2, 1, 2, 
+	1, 4, 0, 0, 2, 3, 1, 1, 
+	2, 2, 1, 2, 1, 1, 2, 1, 
+	2, 1, 2, 2, 2, 1, 1, 4, 
+	2, 0, 0, 0, 1, 0, 1, 0, 
+	1, 0, 1, 1, 0, 2, 1, 1, 
+	1, 2, 2, 1, 1, 2, 2, 1, 
+	1, 3, 2, 2, 0, 0, 2, 0, 
+	0, 0, 0, 1, 4, 1, 0, 2, 
+	1, 2, 2, 0, 2, 2, 1, 1, 
+	2, 6, 1, 1, 1, 1, 2, 2, 
+	1, 1, 1, 2, 2, 0, 1, 1, 
+	1, 1, 0, 1, 0, 3, 3, 1, 
+	2, 2, 2, 0, 5, 1, 1, 0, 
+	1, 1, 1, 1, 1, 2, 1, 1, 
+	4, 1, 1, 1, 1, 1, 4, 1, 
+	2, 2, 5, 2, 6, 2, 8, 4, 
+	2, 5, 0, 3, 2, 4, 1, 6, 
+	2, 4, 4, 1, 1, 2, 1, 2, 
+	1, 4, 0, 0, 4, 4, 1, 1, 
+	2, 2, 2, 2, 1, 1, 6, 2, 
+	5, 1, 3, 3, 4, 4, 4, 4, 
+	2, 0, 0, 1, 1, 0, 1, 0, 
+	1, 1, 0, 2, 1, 1, 2, 4, 
+	1, 2, 4, 1, 5, 0, 3, 2, 
+	1, 0, 0, 2, 0, 0, 0, 0, 
+	1, 4, 1, 0, 2, 1, 4, 2, 
+	0, 4, 3, 4, 2, 2, 6, 2, 
+	2, 4, 1, 4, 2, 4, 1, 3, 
+	3, 2, 2, 0, 1, 1, 1, 0, 
+	1, 0, 3, 3, 1, 2, 2, 2, 
+	0, 5, 1, 1, 0, 1, 0, 1, 
+	1, 1, 0, 0, 0, 0, 1, 1, 
+	1, 0, 0, 1, 2, 2, 1, 1, 
+	1, 1, 2, 1, 1, 4, 1, 1, 
+	1, 1, 2, 4, 1, 2, 1, 2, 
+	2, 5, 6, 2, 2, 5, 1, 3, 
+	2, 3, 5, 2, 3, 1, 3, 1, 
+	1, 2, 1, 2, 1, 4, 0, 0, 
+	2, 3, 1, 1, 2, 2, 1, 2, 
+	1, 1, 2, 1, 2, 1, 2, 2, 
+	2, 1, 1, 4, 2, 0, 0, 0, 
+	1, 0, 1, 0, 1, 0, 1, 1, 
+	0, 2, 1, 1, 1, 2, 2, 1, 
+	1, 2, 2, 1, 1, 3, 2, 2, 
+	0, 0, 2, 0, 0, 0, 0, 1, 
+	4, 1, 0, 2, 1, 2, 2, 0, 
+	2, 2, 1, 1, 2, 6, 1, 1, 
+	1, 1, 2, 2, 1, 1, 1, 2, 
+	2, 0, 1, 1, 1, 1, 0, 1, 
+	0, 3, 3, 1, 2, 2, 2, 0, 
+	5, 1, 1, 0, 1, 1, 1, 1, 
+	1, 2, 1, 1, 4, 1, 1, 1, 
+	1, 1, 4, 1, 2, 2, 5, 2, 
+	6, 2, 8, 4, 2, 5, 0, 3, 
+	2, 4, 1, 6, 2, 4, 4, 1, 
+	1, 2, 1, 2, 1, 4, 0, 0, 
+	4, 4, 1, 1, 2, 2, 2, 2, 
+	1, 1, 6, 2, 5, 1, 3, 3, 
+	4, 4, 4, 4, 2, 0, 0, 1, 
+	1, 0, 1, 0, 1, 1, 0, 2, 
+	1, 1, 2, 4, 1, 2, 4, 1, 
+	5, 0, 3, 2, 1, 0, 0, 2, 
+	0, 0, 0, 0, 1, 4, 1, 0, 
+	2, 1, 4, 2, 0, 4, 3, 4, 
+	2, 2, 6, 2, 2, 4, 1, 4, 
+	2, 4, 1, 3, 3, 2, 2, 0, 
+	1, 1, 1, 0, 1, 0, 3, 3, 
+	1, 2, 2, 2, 0, 5, 1, 1, 
+	0, 1, 0, 1, 1, 1, 0, 0, 
+	0, 0, 1, 1, 1, 0, 0, 1, 
+	2, 3, 1, 1, 1, 1, 1, 1, 
+	1, 0, 1, 0, 1, 1, 0, 1, 
+	1, 0, 1, 0, 1, 3, 1, 2, 
+	2, 1, 0, 0, 1, 0, 0, 0, 
+	0, 0, 1, 0, 1, 1, 2, 2, 
+	2, 1, 3, 2, 1, 1, 3, 1, 
+	3, 3, 1, 0, 0, 0, 0, 0, 
+	1, 1, 1, 2, 2, 4, 1, 1, 
+	2, 1, 1, 1, 3, 1, 2, 1, 
+	2, 1, 2, 0, 0, 1, 1, 5, 
+	9, 2, 1, 3, 5, 3, 1, 6, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 2, 
+	1, 1, 4, 1, 1, 1, 1, 2, 
+	4, 1, 2, 1, 2, 2, 5, 6, 
+	2, 2, 5, 1, 3, 2, 3, 5, 
+	2, 3, 1, 3, 1, 1, 2, 1, 
+	2, 1, 4, 0, 0, 2, 3, 1, 
+	1, 2, 2, 1, 2, 1, 1, 2, 
+	1, 2, 1, 2, 2, 2, 1, 1, 
+	4, 2, 0, 0, 0, 1, 0, 1, 
+	0, 1, 0, 1, 1, 0, 2, 1, 
+	1, 1, 2, 2, 1, 1, 2, 2, 
+	1, 1, 3, 2, 2, 0, 0, 2, 
+	0, 0, 0, 0, 1, 4, 1, 0, 
+	2, 1, 2, 2, 0, 2, 2, 1, 
+	1, 2, 6, 1, 1, 1, 1, 2, 
+	2, 1, 1, 1, 2, 2, 0, 1, 
+	1, 1, 1, 0, 1, 0, 3, 3, 
+	1, 2, 2, 2, 0, 5, 1, 1, 
+	0, 1, 1, 1, 1, 1, 2, 1, 
+	1, 4, 1, 1, 1, 1, 1, 4, 
+	1, 2, 2, 5, 2, 6, 2, 8, 
+	4, 2, 5, 0, 3, 2, 4, 1, 
+	6, 2, 4, 4, 1, 1, 2, 1, 
+	2, 1, 4, 0, 0, 4, 4, 1, 
+	1, 2, 2, 2, 2, 1, 1, 6, 
+	2, 5, 1, 3, 3, 4, 4, 4, 
+	4, 2, 0, 0, 1, 1, 0, 1, 
+	0, 1, 1, 0, 2, 1, 1, 2, 
+	4, 1, 2, 4, 1, 5, 0, 3, 
+	2, 1, 0, 0, 2, 0, 0, 0, 
+	0, 1, 4, 1, 0, 2, 1, 4, 
+	2, 0, 4, 3, 4, 2, 2, 6, 
+	2, 2, 4, 1, 4, 2, 4, 1, 
+	3, 3, 2, 2, 0, 1, 1, 1, 
+	0, 1, 0, 3, 3, 1, 2, 2, 
+	2, 0, 5, 1, 1, 0, 1, 0, 
+	1, 1, 1, 0, 0, 0, 0, 1, 
+	1, 1, 0, 0, 0, 1, 0, 1, 
+	1, 0, 1, 1, 0, 1, 0, 1, 
+	3, 1, 2, 2, 1, 0, 0, 1, 
+	0, 0, 0, 0, 0, 1, 0, 1, 
+	1, 2, 2, 1, 1, 5, 1, 1, 
+	1, 1, 2, 1, 1, 4, 1, 1, 
+	1, 1, 2, 4, 1, 2, 1, 2, 
+	2, 5, 6, 2, 2, 5, 1, 3, 
+	2, 3, 5, 2, 3, 1, 3, 1, 
+	1, 2, 1, 2, 1, 4, 0, 0, 
+	2, 3, 1, 1, 2, 2, 1, 2, 
+	1, 1, 2, 1, 2, 1, 2, 2, 
+	2, 1, 1, 4, 2, 0, 0, 1, 
+	1, 0, 1, 0, 1, 1, 0, 2, 
+	1, 1, 1, 2, 2, 1, 1, 2, 
+	2, 1, 1, 3, 2, 2, 0, 0, 
+	2, 0, 0, 0, 0, 1, 4, 1, 
+	0, 2, 1, 2, 2, 0, 2, 2, 
+	1, 1, 2, 6, 1, 1, 1, 1, 
+	2, 2, 1, 1, 1, 2, 2, 0, 
+	1, 1, 1, 1, 0, 1, 0, 3, 
+	3, 1, 2, 2, 2, 0, 5, 1, 
+	1, 0, 1, 1, 1, 0, 0, 0, 
+	0, 0, 1, 1, 1, 1, 1, 2, 
+	1, 1, 4, 1, 1, 1, 1, 1, 
+	4, 1, 2, 2, 5, 2, 6, 2, 
+	8, 4, 2, 5, 0, 3, 2, 4, 
+	1, 6, 2, 4, 4, 1, 1, 2, 
+	1, 2, 1, 4, 0, 0, 4, 4, 
+	1, 1, 2, 2, 2, 2, 1, 1, 
+	6, 2, 5, 1, 3, 3, 4, 4, 
+	4, 4, 2, 0, 0, 1, 1, 0, 
+	1, 0, 1, 1, 0, 2, 1, 1, 
+	2, 4, 1, 2, 4, 1, 5, 0, 
+	3, 2, 1, 0, 0, 2, 0, 0, 
+	0, 0, 1, 4, 1, 0, 2, 1, 
+	4, 2, 0, 4, 3, 4, 2, 2, 
+	6, 2, 2, 4, 1, 4, 2, 4, 
+	1, 3, 3, 2, 2, 0, 1, 1, 
+	1, 0, 1, 0, 3, 3, 1, 2, 
+	2, 2, 0, 5, 1, 1, 0, 1, 
+	0, 1, 1, 1, 0, 0, 0, 3, 
+	1, 1, 1, 1, 1, 2, 1, 1, 
+	4, 1, 1, 1, 1, 1, 4, 1, 
+	2, 2, 1, 1, 1, 1, 2, 1, 
+	1, 4, 1, 1, 1, 1, 2, 4, 
+	1, 2, 1, 2, 2, 5, 6, 2, 
+	2, 5, 1, 3, 2, 3, 5, 2, 
+	3, 1, 3, 1, 1, 2, 1, 2, 
+	1, 4, 0, 0, 2, 3, 1, 1, 
+	2, 2, 1, 2, 1, 1, 2, 1, 
+	2, 1, 2, 2, 2, 1, 1, 4, 
+	2, 0, 0, 0, 1, 0, 1, 0, 
+	1, 0, 1, 1, 0, 2, 1, 1, 
+	1, 2, 2, 1, 1, 2, 2, 1, 
+	1, 3, 2, 2, 0, 0, 2, 0, 
+	0, 0, 0, 1, 4, 1, 0, 2, 
+	1, 2, 2, 0, 2, 2, 1, 1, 
+	2, 6, 1, 1, 1, 1, 2, 2, 
+	1, 1, 1, 2, 2, 0, 1, 1, 
+	1, 1, 0, 1, 0, 3, 3, 1, 
+	2, 2, 2, 0, 5, 1, 1, 0, 
+	1, 0, 0, 0, 1, 1, 1, 0, 
+	0, 5, 2, 6, 2, 8, 4, 2, 
+	5, 0, 3, 2, 4, 1, 6, 2, 
+	4, 4, 1, 1, 2, 1, 2, 1, 
+	4, 0, 0, 4, 4, 1, 1, 2, 
+	2, 2, 2, 1, 1, 6, 2, 5, 
+	1, 3, 3, 4, 4, 4, 4, 2, 
+	0, 0, 1, 1, 0, 1, 0, 1, 
+	1, 0, 2, 1, 1, 2, 4, 1, 
+	2, 4, 1, 5, 0, 3, 2, 1, 
+	0, 0, 2, 0, 0, 0, 0, 1, 
+	4, 1, 0, 2, 1, 4, 2, 0, 
+	4, 3, 4, 2, 2, 6, 2, 2, 
+	4, 1, 4, 2, 4, 1, 3, 3, 
+	2, 2, 0, 1, 1, 1, 0, 1, 
+	0, 3, 3, 1, 2, 2, 2, 0, 
+	5, 1, 1, 0, 1, 0, 1, 1, 
+	1, 0, 1, 3, 1, 3, 3, 1, 
+	0, 0, 0, 0, 0, 1, 1, 1, 
+	3, 2, 4, 1, 0, 1, 1, 1, 
+	3, 1, 1, 1, 3, 1, 3, 1, 
+	3, 1, 2, 1, 1, 1, 1, 2, 
+	1, 1, 4, 1, 1, 1, 1, 2, 
+	4, 1, 2, 1, 2, 2, 5, 6, 
+	2, 2, 5, 1, 3, 2, 3, 5, 
+	2, 3, 1, 3, 1, 1, 2, 1, 
+	2, 1, 4, 0, 0, 2, 3, 1, 
+	1, 2, 2, 1, 2, 1, 1, 2, 
+	1, 2, 1, 2, 2, 2, 1, 1, 
+	4, 2, 0, 0, 0, 1, 0, 1, 
+	0, 1, 0, 1, 1, 0, 2, 1, 
+	1, 1, 2, 2, 1, 1, 2, 2, 
+	1, 1, 3, 2, 2, 0, 0, 2, 
+	0, 0, 0, 0, 1, 4, 1, 0, 
+	2, 1, 2, 2, 0, 2, 2, 1, 
+	1, 2, 6, 1, 1, 1, 1, 2, 
+	2, 1, 1, 1, 2, 2, 0, 1, 
+	1, 1, 1, 0, 1, 0, 3, 3, 
+	1, 2, 2, 2, 0, 5, 1, 1, 
+	0, 1, 1, 1, 1, 1, 2, 1, 
+	1, 4, 1, 1, 1, 1, 1, 4, 
+	1, 2, 2, 5, 2, 6, 2, 8, 
+	4, 2, 5, 0, 3, 2, 4, 1, 
+	6, 2, 4, 4, 1, 1, 2, 1, 
+	2, 1, 4, 0, 0, 4, 4, 1, 
+	1, 2, 2, 2, 2, 1, 1, 6, 
+	2, 5, 1, 3, 3, 4, 4, 4, 
+	4, 2, 0, 0, 1, 1, 0, 1, 
+	0, 1, 1, 0, 2, 1, 1, 2, 
+	4, 1, 2, 4, 1, 5, 0, 3, 
+	2, 1, 0, 0, 2, 0, 0, 0, 
+	0, 1, 4, 1, 0, 2, 1, 4, 
+	2, 0, 4, 3, 4, 2, 2, 6, 
+	2, 2, 4, 1, 4, 2, 4, 1, 
+	3, 3, 2, 2, 0, 1, 1, 1, 
+	0, 1, 0, 3, 3, 1, 2, 2, 
+	2, 0, 5, 1, 1, 0, 1, 0, 
+	1, 1, 1, 0, 0, 0, 0, 1, 
+	1, 1, 0, 0, 0, 0, 1, 1, 
+	5, 9, 2, 1, 3, 5, 3, 1, 
+	6, 1, 1, 2, 2, 2, 6, 0, 
+	0, 0, 4, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 
+}
+
+var _graphclust_index_offsets []int16 = []int16{
+	0, 0, 2, 4, 6, 8, 11, 15, 
+	17, 20, 25, 28, 30, 32, 34, 63, 
+	68, 70, 73, 76, 80, 84, 90, 97, 
+	102, 106, 112, 115, 120, 123, 129, 135, 
+	138, 144, 146, 152, 155, 157, 161, 163, 
+	169, 171, 176, 178, 200, 203, 207, 212, 
+	214, 217, 220, 222, 225, 227, 230, 233, 
+	235, 241, 243, 246, 249, 252, 254, 256, 
+	262, 265, 271, 274, 281, 283, 285, 287, 
+	289, 291, 294, 296, 298, 314, 317, 319, 
+	321, 326, 329, 332, 334, 336, 339, 342, 
+	344, 348, 353, 357, 360, 364, 366, 369, 
+	377, 383, 385, 387, 389, 395, 397, 421, 
+	424, 426, 429, 432, 434, 437, 440, 443, 
+	445, 449, 457, 459, 461, 463, 465, 468, 
+	471, 473, 475, 477, 480, 483, 488, 490, 
+	492, 494, 496, 498, 500, 507, 511, 515, 
+	517, 520, 523, 527, 531, 537, 539, 541, 
+	545, 547, 549, 551, 553, 556, 560, 562, 
+	565, 570, 573, 575, 577, 579, 610, 615, 
+	617, 620, 626, 634, 640, 649, 654, 665, 
+	673, 678, 686, 690, 697, 701, 708, 714, 
+	723, 728, 737, 746, 750, 752, 757, 759, 
+	765, 768, 773, 775, 797, 803, 808, 814, 
+	816, 819, 822, 826, 831, 833, 836, 844, 
+	848, 858, 860, 867, 872, 880, 887, 892, 
+	900, 903, 909, 912, 914, 916, 918, 920, 
+	923, 925, 927, 943, 946, 948, 950, 957, 
+	962, 964, 967, 975, 978, 984, 989, 994, 
+	1001, 1007, 1011, 1013, 1016, 1024, 1030, 1032, 
+	1034, 1036, 1042, 1044, 1068, 1072, 1074, 1080, 
+	1084, 1086, 1092, 1096, 1103, 1107, 1113, 1122, 
+	1125, 1129, 1137, 1140, 1147, 1150, 1156, 1158, 
+	1164, 1169, 1174, 1180, 1185, 1187, 1189, 1191, 
+	1193, 1195, 1202, 1208, 1212, 1214, 1217, 1220, 
+	1224, 1228, 1234, 1236, 1238, 1240, 1242, 1244, 
+	1250, 1252, 1254, 1255, 1257, 1259, 1261, 1267, 
+	1269, 1271, 1272, 1279, 1281, 1285, 1289, 1291, 
+	1293, 1295, 1298, 1302, 1304, 1307, 1312, 1315, 
+	1317, 1319, 1321, 1350, 1355, 1357, 1360, 1363, 
+	1367, 1371, 1377, 1384, 1389, 1393, 1399, 1402, 
+	1407, 1410, 1416, 1422, 1425, 1431, 1433, 1439, 
+	1442, 1444, 1448, 1450, 1456, 1458, 1463, 1465, 
+	1487, 1490, 1494, 1499, 1501, 1504, 1507, 1509, 
+	1512, 1514, 1517, 1520, 1522, 1528, 1530, 1533, 
+	1536, 1539, 1541, 1543, 1549, 1552, 1558, 1561, 
+	1568, 1570, 1572, 1574, 1576, 1578, 1581, 1583, 
+	1585, 1601, 1604, 1606, 1608, 1613, 1616, 1619, 
+	1621, 1623, 1626, 1629, 1631, 1635, 1640, 1644, 
+	1647, 1651, 1653, 1656, 1664, 1670, 1672, 1674, 
+	1676, 1682, 1684, 1708, 1711, 1713, 1716, 1719, 
+	1721, 1724, 1727, 1730, 1732, 1736, 1744, 1746, 
+	1748, 1750, 1752, 1755, 1758, 1760, 1762, 1764, 
+	1767, 1770, 1775, 1777, 1779, 1781, 1783, 1785, 
+	1787, 1794, 1798, 1802, 1804, 1807, 1810, 1814, 
+	1818, 1824, 1826, 1828, 1832, 1834, 1836, 1838, 
+	1840, 1843, 1847, 1849, 1852, 1857, 1860, 1862, 
+	1864, 1866, 1897, 1902, 1904, 1907, 1913, 1921, 
+	1927, 1936, 1941, 1952, 1960, 1965, 1973, 1977, 
+	1984, 1988, 1995, 2001, 2010, 2015, 2024, 2033, 
+	2037, 2039, 2044, 2046, 2052, 2055, 2060, 2062, 
+	2084, 2090, 2095, 2101, 2103, 2106, 2109, 2113, 
+	2118, 2120, 2123, 2131, 2135, 2145, 2147, 2154, 
+	2159, 2167, 2174, 2179, 2187, 2190, 2196, 2199, 
+	2201, 2203, 2205, 2207, 2210, 2212, 2214, 2230, 
+	2233, 2235, 2237, 2244, 2249, 2251, 2254, 2262, 
+	2265, 2271, 2276, 2281, 2288, 2294, 2298, 2300, 
+	2303, 2311, 2317, 2319, 2321, 2323, 2329, 2331, 
+	2355, 2359, 2361, 2367, 2371, 2373, 2379, 2383, 
+	2390, 2394, 2400, 2409, 2412, 2416, 2424, 2427, 
+	2434, 2437, 2443, 2445, 2451, 2456, 2461, 2467, 
+	2472, 2474, 2476, 2478, 2480, 2482, 2489, 2495, 
+	2499, 2501, 2504, 2507, 2511, 2515, 2521, 2523, 
+	2525, 2527, 2529, 2531, 2537, 2539, 2541, 2542, 
+	2544, 2546, 2548, 2554, 2556, 2558, 2559, 2566, 
+	2568, 2571, 2575, 2578, 2581, 2585, 2588, 2591, 
+	2598, 2600, 2625, 2627, 2652, 2654, 2656, 2680, 
+	2682, 2684, 2686, 2688, 2691, 2693, 2697, 2699, 
+	2730, 2733, 2738, 2762, 2765, 2767, 2770, 2773, 
+	2777, 2780, 2783, 2787, 2788, 2844, 2900, 2930, 
+	2934, 2937, 2944, 2950, 2953, 2956, 2959, 2963, 
+	2965, 2983, 2987, 2992, 2995, 2998, 3002, 3005, 
+	3008, 3012, 3068, 3124, 3154, 3158, 3163, 3167, 
+	3169, 3173, 3179, 3183, 3186, 3190, 3193, 3196, 
+	3199, 3202, 3215, 3218, 3226, 3228, 3230, 3233, 
+	3239, 3251, 3257, 3261, 3266, 3272, 3277, 3280, 
+	3290, 3292, 3295, 3300, 3302, 3305, 3308, 3312, 
+	3315, 3318, 3325, 3327, 3329, 3331, 3333, 3336, 
+	3340, 3342, 3345, 3350, 3353, 3355, 3357, 3359, 
+	3388, 3393, 3395, 3398, 3401, 3405, 3409, 3415, 
+	3422, 3427, 3431, 3437, 3440, 3445, 3448, 3454, 
+	3460, 3463, 3469, 3471, 3477, 3480, 3482, 3486, 
+	3488, 3494, 3496, 3501, 3503, 3525, 3528, 3532, 
+	3537, 3539, 3542, 3545, 3547, 3550, 3552, 3555, 
+	3558, 3560, 3566, 3568, 3571, 3574, 3577, 3579, 
+	3581, 3587, 3590, 3596, 3599, 3606, 3608, 3610, 
+	3612, 3614, 3616, 3619, 3621, 3623, 3639, 3642, 
+	3644, 3646, 3651, 3654, 3657, 3659, 3661, 3664, 
+	3667, 3669, 3673, 3678, 3682, 3685, 3689, 3691, 
+	3694, 3702, 3708, 3710, 3712, 3714, 3720, 3722, 
+	3746, 3749, 3751, 3754, 3757, 3759, 3762, 3765, 
+	3768, 3770, 3774, 3782, 3784, 3786, 3788, 3790, 
+	3793, 3796, 3798, 3800, 3802, 3805, 3808, 3813, 
+	3815, 3817, 3819, 3821, 3823, 3825, 3832, 3836, 
+	3840, 3842, 3845, 3848, 3852, 3856, 3862, 3864, 
+	3866, 3870, 3872, 3874, 3876, 3878, 3881, 3885, 
+	3887, 3890, 3895, 3898, 3900, 3902, 3904, 3935, 
+	3940, 3942, 3945, 3951, 3959, 3965, 3974, 3979, 
+	3990, 3998, 4003, 4011, 4015, 4022, 4026, 4033, 
+	4039, 4048, 4053, 4062, 4071, 4075, 4077, 4082, 
+	4084, 4090, 4093, 4098, 4100, 4122, 4128, 4133, 
+	4139, 4141, 4144, 4147, 4151, 4156, 4158, 4161, 
+	4169, 4173, 4183, 4185, 4192, 4197, 4205, 4212, 
+	4217, 4225, 4228, 4234, 4237, 4239, 4241, 4243, 
+	4245, 4248, 4250, 4252, 4268, 4271, 4273, 4275, 
+	4282, 4287, 4289, 4292, 4300, 4303, 4309, 4314, 
+	4319, 4326, 4332, 4336, 4338, 4341, 4349, 4355, 
+	4357, 4359, 4361, 4367, 4369, 4393, 4397, 4399, 
+	4405, 4409, 4411, 4417, 4421, 4428, 4432, 4438, 
+	4447, 4450, 4454, 4462, 4465, 4472, 4475, 4481, 
+	4483, 4489, 4494, 4499, 4505, 4510, 4512, 4514, 
+	4516, 4518, 4520, 4527, 4533, 4537, 4539, 4542, 
+	4545, 4549, 4553, 4559, 4561, 4563, 4565, 4567, 
+	4569, 4575, 4577, 4579, 4580, 4582, 4584, 4586, 
+	4592, 4594, 4596, 4597, 4604, 4629, 4631, 4656, 
+	4658, 4660, 4684, 4686, 4688, 4690, 4692, 4695, 
+	4697, 4701, 4703, 4734, 4737, 4742, 4766, 4769, 
+	4771, 4774, 4777, 4781, 4784, 4787, 4791, 4792, 
+	4848, 4904, 4934, 4938, 4941, 4948, 4956, 4958, 
+	4960, 4962, 4965, 4969, 4971, 4974, 4979, 4982, 
+	4984, 4986, 4988, 5017, 5022, 5024, 5027, 5030, 
+	5034, 5038, 5044, 5051, 5056, 5060, 5066, 5069, 
+	5074, 5077, 5083, 5089, 5092, 5098, 5100, 5106, 
+	5109, 5111, 5115, 5117, 5123, 5125, 5130, 5132, 
+	5154, 5157, 5161, 5166, 5168, 5171, 5174, 5176, 
+	5179, 5181, 5184, 5187, 5189, 5195, 5197, 5200, 
+	5203, 5206, 5208, 5210, 5216, 5219, 5225, 5228, 
+	5230, 5232, 5234, 5236, 5239, 5241, 5243, 5259, 
+	5262, 5264, 5266, 5271, 5274, 5277, 5279, 5281, 
+	5284, 5287, 5289, 5293, 5298, 5302, 5305, 5309, 
+	5311, 5314, 5321, 5327, 5329, 5331, 5333, 5339, 
+	5341, 5365, 5368, 5370, 5373, 5376, 5378, 5381, 
+	5384, 5387, 5389, 5393, 5401, 5403, 5405, 5407, 
+	5409, 5412, 5415, 5417, 5419, 5421, 5424, 5427, 
+	5432, 5434, 5436, 5438, 5440, 5442, 5444, 5451, 
+	5455, 5459, 5461, 5464, 5467, 5471, 5475, 5481, 
+	5483, 5485, 5487, 5493, 5495, 5497, 5498, 5505, 
+	5507, 5515, 5519, 5521, 5523, 5525, 5527, 5530, 
+	5534, 5536, 5539, 5544, 5547, 5549, 5551, 5553, 
+	5584, 5589, 5591, 5594, 5600, 5608, 5614, 5623, 
+	5628, 5639, 5647, 5652, 5660, 5664, 5671, 5675, 
+	5682, 5688, 5697, 5702, 5711, 5720, 5724, 5726, 
+	5731, 5733, 5739, 5742, 5747, 5749, 5771, 5777, 
+	5782, 5788, 5790, 5793, 5796, 5800, 5805, 5807, 
+	5810, 5818, 5822, 5832, 5834, 5841, 5846, 5854, 
+	5861, 5866, 5874, 5877, 5883, 5886, 5888, 5890, 
+	5892, 5894, 5897, 5899, 5901, 5917, 5920, 5922, 
+	5924, 5931, 5936, 5938, 5941, 5949, 5952, 5958, 
+	5963, 5968, 5975, 5981, 5985, 5987, 5990, 5998, 
+	6004, 6006, 6008, 6010, 6016, 6018, 6042, 6046, 
+	6048, 6054, 6058, 6060, 6066, 6070, 6077, 6081, 
+	6087, 6096, 6099, 6103, 6111, 6114, 6121, 6124, 
+	6130, 6132, 6138, 6143, 6148, 6154, 6159, 6161, 
+	6163, 6165, 6167, 6169, 6176, 6182, 6186, 6188, 
+	6191, 6194, 6198, 6202, 6208, 6210, 6212, 6214, 
+	6216, 6218, 6224, 6226, 6228, 6229, 6231, 6233, 
+	6237, 6240, 6242, 6244, 6246, 6249, 6253, 6255, 
+	6258, 6263, 6266, 6268, 6270, 6272, 6303, 6308, 
+	6310, 6313, 6319, 6321, 6323, 6325, 6328, 6332, 
+	6334, 6337, 6342, 6345, 6347, 6349, 6351, 6380, 
+	6385, 6387, 6390, 6393, 6397, 6401, 6407, 6414, 
+	6419, 6423, 6429, 6432, 6437, 6440, 6446, 6452, 
+	6455, 6461, 6463, 6469, 6472, 6474, 6478, 6480, 
+	6486, 6488, 6493, 6495, 6517, 6520, 6524, 6529, 
+	6531, 6534, 6537, 6539, 6542, 6544, 6547, 6550, 
+	6552, 6558, 6560, 6563, 6566, 6569, 6571, 6573, 
+	6579, 6582, 6588, 6591, 6598, 6600, 6602, 6604, 
+	6606, 6608, 6611, 6613, 6615, 6631, 6634, 6636, 
+	6638, 6643, 6646, 6649, 6651, 6653, 6656, 6659, 
+	6661, 6665, 6670, 6674, 6677, 6681, 6683, 6686, 
+	6694, 6700, 6702, 6704, 6706, 6712, 6714, 6738, 
+	6741, 6743, 6746, 6749, 6751, 6754, 6757, 6760, 
+	6762, 6766, 6774, 6776, 6778, 6780, 6782, 6785, 
+	6788, 6790, 6792, 6794, 6797, 6800, 6805, 6807, 
+	6809, 6811, 6813, 6815, 6817, 6824, 6828, 6832, 
+	6834, 6837, 6840, 6844, 6848, 6854, 6856, 6858, 
+	6862, 6864, 6866, 6868, 6870, 6876, 6878, 6880, 
+	6881, 6888, 6896, 6902, 6911, 6916, 6927, 6935, 
+	6940, 6948, 6952, 6959, 6963, 6970, 6976, 6985, 
+	6990, 6999, 7008, 7012, 7014, 7019, 7021, 7027, 
+	7030, 7035, 7037, 7059, 7065, 7070, 7076, 7078, 
+	7081, 7084, 7088, 7093, 7095, 7098, 7106, 7110, 
+	7120, 7122, 7129, 7134, 7142, 7149, 7154, 7162, 
+	7165, 7171, 7174, 7176, 7178, 7180, 7182, 7185, 
+	7187, 7189, 7205, 7208, 7210, 7212, 7219, 7224, 
+	7226, 7229, 7237, 7240, 7246, 7251, 7256, 7263, 
+	7269, 7273, 7275, 7278, 7286, 7292, 7294, 7296, 
+	7298, 7304, 7306, 7330, 7334, 7336, 7342, 7346, 
+	7348, 7354, 7358, 7365, 7369, 7375, 7384, 7387, 
+	7391, 7399, 7402, 7409, 7412, 7418, 7420, 7426, 
+	7431, 7436, 7442, 7447, 7449, 7451, 7453, 7455, 
+	7457, 7464, 7470, 7474, 7476, 7479, 7482, 7486, 
+	7490, 7496, 7498, 7500, 7502, 7504, 7506, 7512, 
+	7514, 7516, 7517, 7520, 7524, 7526, 7544, 7548, 
+	7553, 7556, 7559, 7563, 7566, 7569, 7573, 7629, 
+	7685, 7718, 7722, 7727, 7729, 7730, 7732, 7736, 
+	7739, 7744, 7750, 7754, 7757, 7761, 7764, 7768, 
+	7771, 7775, 7788, 7791, 7793, 7795, 7797, 7800, 
+	7804, 7806, 7809, 7814, 7817, 7819, 7821, 7823, 
+	7852, 7857, 7859, 7862, 7865, 7869, 7873, 7879, 
+	7886, 7891, 7895, 7901, 7904, 7909, 7912, 7918, 
+	7924, 7927, 7933, 7935, 7941, 7944, 7946, 7950, 
+	7952, 7958, 7960, 7965, 7967, 7989, 7992, 7996, 
+	8001, 8003, 8006, 8009, 8011, 8014, 8016, 8019, 
+	8022, 8024, 8030, 8032, 8035, 8038, 8041, 8043, 
+	8045, 8051, 8054, 8060, 8063, 8070, 8072, 8074, 
+	8076, 8078, 8080, 8083, 8085, 8087, 8103, 8106, 
+	8108, 8110, 8115, 8118, 8121, 8123, 8125, 8128, 
+	8131, 8133, 8137, 8142, 8146, 8149, 8153, 8155, 
+	8158, 8166, 8172, 8174, 8176, 8178, 8184, 8186, 
+	8210, 8213, 8215, 8218, 8221, 8223, 8226, 8229, 
+	8232, 8234, 8238, 8246, 8248, 8250, 8252, 8254, 
+	8257, 8260, 8262, 8264, 8266, 8269, 8272, 8277, 
+	8279, 8281, 8283, 8285, 8287, 8289, 8296, 8300, 
+	8304, 8306, 8309, 8312, 8316, 8320, 8326, 8328, 
+	8330, 8334, 8336, 8338, 8340, 8342, 8345, 8349, 
+	8351, 8354, 8359, 8362, 8364, 8366, 8368, 8399, 
+	8404, 8406, 8409, 8415, 8423, 8429, 8438, 8443, 
+	8454, 8462, 8467, 8475, 8479, 8486, 8490, 8497, 
+	8503, 8512, 8517, 8526, 8535, 8539, 8541, 8546, 
+	8548, 8554, 8557, 8562, 8564, 8586, 8592, 8597, 
+	8603, 8605, 8608, 8611, 8615, 8620, 8622, 8625, 
+	8633, 8637, 8647, 8649, 8656, 8661, 8669, 8676, 
+	8681, 8689, 8692, 8698, 8701, 8703, 8705, 8707, 
+	8709, 8712, 8714, 8716, 8732, 8735, 8737, 8739, 
+	8746, 8751, 8753, 8756, 8764, 8767, 8773, 8778, 
+	8783, 8790, 8796, 8800, 8802, 8805, 8813, 8819, 
+	8821, 8823, 8825, 8831, 8833, 8857, 8861, 8863, 
+	8869, 8873, 8875, 8881, 8885, 8892, 8896, 8902, 
+	8911, 8914, 8918, 8926, 8929, 8936, 8939, 8945, 
+	8947, 8953, 8958, 8963, 8969, 8974, 8976, 8978, 
+	8980, 8982, 8984, 8991, 8997, 9001, 9003, 9006, 
+	9009, 9013, 9017, 9023, 9025, 9027, 9029, 9031, 
+	9033, 9039, 9041, 9043, 9044, 9046, 9048, 9050, 
+	9056, 9058, 9060, 9061, 9068, 9076, 9078, 9080, 
+	9083, 9089, 9101, 9107, 9111, 9116, 9122, 9127, 
+	9130, 9140, 9142, 9145, 9153, 9156, 9159, 9183, 
+	9204, 9225, 9246, 9265, 9286, 9307, 9328, 9352, 
+	9374, 9396, 9418, 9439, 9463, 9484, 9505, 9526, 
+	9548, 9570, 9592, 9613, 9634, 9655, 9676, 9697, 
+	9718, 9739, 9760, 9781, 
+}
+
+var _graphclust_indicies []int16 = []int16{
+	0, 1, 3, 2, 2, 3, 3, 2, 
+	3, 3, 2, 3, 3, 3, 2, 3, 
+	2, 3, 3, 2, 3, 3, 3, 3, 
+	2, 3, 3, 2, 2, 3, 3, 2, 
+	3, 2, 4, 5, 6, 7, 8, 10, 
+	11, 12, 14, 15, 16, 17, 18, 19, 
+	20, 21, 22, 23, 24, 25, 26, 27, 
+	28, 29, 30, 31, 9, 13, 2, 3, 
+	3, 3, 3, 2, 3, 2, 3, 3, 
+	2, 2, 2, 3, 2, 2, 2, 3, 
+	3, 3, 3, 2, 2, 2, 2, 2, 
+	2, 3, 2, 2, 2, 2, 2, 2, 
+	3, 2, 2, 2, 2, 3, 3, 3, 
+	3, 2, 3, 3, 3, 3, 3, 2, 
+	3, 3, 2, 3, 3, 3, 3, 2, 
+	3, 3, 2, 2, 2, 2, 2, 2, 
+	3, 3, 3, 3, 3, 3, 2, 3, 
+	3, 2, 2, 2, 2, 2, 2, 3, 
+	3, 2, 3, 3, 3, 3, 3, 2, 
+	3, 3, 2, 3, 2, 3, 3, 3, 
+	2, 3, 2, 3, 3, 3, 3, 3, 
+	2, 3, 2, 3, 3, 3, 3, 2, 
+	3, 2, 32, 33, 34, 35, 36, 37, 
+	38, 39, 40, 41, 42, 43, 44, 45, 
+	46, 47, 48, 49, 50, 51, 52, 2, 
+	3, 3, 2, 3, 3, 3, 2, 3, 
+	3, 3, 3, 2, 3, 2, 3, 3, 
+	2, 3, 3, 2, 3, 2, 2, 2, 
+	3, 3, 2, 3, 3, 2, 3, 3, 
+	2, 3, 2, 3, 3, 3, 3, 3, 
+	2, 3, 2, 3, 3, 2, 2, 2, 
+	3, 3, 3, 2, 3, 2, 3, 2, 
+	3, 3, 3, 3, 3, 2, 3, 3, 
+	2, 53, 54, 55, 56, 57, 2, 3, 
+	58, 2, 53, 54, 59, 55, 56, 57, 
+	2, 3, 2, 3, 2, 3, 2, 3, 
+	2, 3, 2, 60, 61, 2, 3, 2, 
+	3, 2, 62, 63, 64, 65, 66, 67, 
+	68, 69, 70, 71, 72, 73, 74, 75, 
+	76, 2, 3, 3, 2, 3, 2, 3, 
+	2, 3, 3, 3, 3, 2, 3, 3, 
+	2, 2, 2, 3, 3, 2, 3, 2, 
+	3, 3, 2, 2, 2, 3, 3, 2, 
+	3, 3, 3, 2, 3, 3, 3, 3, 
+	2, 3, 3, 3, 2, 3, 3, 2, 
+	77, 78, 63, 2, 3, 2, 3, 3, 
+	2, 79, 80, 81, 82, 83, 84, 85, 
+	2, 86, 87, 88, 89, 90, 2, 3, 
+	2, 3, 2, 3, 2, 3, 3, 3, 
+	3, 3, 2, 3, 2, 91, 92, 93, 
+	94, 95, 96, 97, 98, 99, 100, 101, 
+	102, 103, 104, 105, 106, 107, 104, 108, 
+	109, 110, 111, 112, 2, 3, 3, 2, 
+	2, 3, 2, 2, 3, 3, 3, 2, 
+	3, 2, 3, 3, 2, 2, 2, 3, 
+	3, 3, 2, 3, 2, 3, 3, 3, 
+	2, 3, 3, 3, 3, 3, 3, 3, 
+	2, 3, 2, 3, 2, 3, 2, 2, 
+	3, 3, 3, 2, 2, 2, 3, 2, 
+	3, 3, 2, 3, 2, 3, 3, 2, 
+	3, 3, 2, 113, 114, 115, 116, 2, 
+	3, 2, 3, 2, 3, 2, 3, 2, 
+	117, 2, 3, 2, 118, 119, 120, 121, 
+	122, 123, 2, 3, 3, 3, 2, 2, 
+	2, 2, 3, 3, 2, 3, 3, 2, 
+	2, 2, 3, 3, 3, 3, 2, 124, 
+	125, 126, 2, 3, 3, 3, 3, 3, 
+	2, 3, 2, 3, 2, 127, 128, 129, 
+	2, 130, 2, 2, 130, 2, 130, 130, 
+	2, 130, 130, 2, 130, 130, 130, 2, 
+	130, 2, 130, 130, 2, 130, 130, 130, 
+	130, 2, 130, 130, 2, 2, 130, 130, 
+	2, 130, 2, 131, 132, 133, 134, 135, 
+	136, 137, 139, 140, 141, 142, 143, 144, 
+	145, 146, 147, 148, 149, 150, 22, 151, 
+	152, 153, 154, 155, 156, 157, 158, 159, 
+	138, 2, 130, 130, 130, 130, 2, 130, 
+	2, 130, 130, 2, 3, 3, 2, 2, 
+	3, 130, 130, 2, 130, 130, 2, 130, 
+	2, 3, 130, 130, 130, 3, 3, 2, 
+	130, 130, 130, 2, 2, 2, 130, 2, 
+	3, 3, 130, 130, 3, 2, 130, 130, 
+	130, 2, 130, 2, 130, 2, 130, 2, 
+	3, 2, 2, 130, 130, 2, 130, 2, 
+	3, 130, 130, 3, 130, 2, 3, 130, 
+	130, 3, 3, 130, 130, 2, 130, 130, 
+	3, 2, 130, 130, 130, 3, 3, 3, 
+	2, 130, 3, 130, 2, 2, 2, 3, 
+	2, 2, 2, 130, 130, 130, 3, 130, 
+	3, 2, 130, 130, 3, 3, 3, 130, 
+	130, 130, 2, 130, 130, 3, 3, 2, 
+	2, 2, 130, 130, 130, 2, 130, 2, 
+	3, 130, 130, 130, 130, 3, 130, 3, 
+	3, 2, 130, 3, 130, 2, 130, 2, 
+	130, 3, 130, 130, 2, 130, 2, 130, 
+	130, 130, 130, 3, 2, 3, 130, 2, 
+	130, 130, 130, 130, 2, 130, 2, 160, 
+	161, 162, 163, 164, 165, 166, 167, 168, 
+	169, 170, 171, 172, 173, 174, 175, 176, 
+	177, 178, 179, 180, 2, 3, 130, 130, 
+	3, 130, 2, 3, 130, 130, 130, 2, 
+	130, 3, 130, 130, 130, 2, 130, 2, 
+	130, 130, 2, 130, 130, 2, 3, 130, 
+	3, 2, 130, 130, 130, 2, 3, 130, 
+	2, 130, 130, 2, 130, 130, 3, 130, 
+	3, 3, 130, 2, 130, 130, 3, 2, 
+	130, 130, 130, 130, 3, 130, 130, 3, 
+	130, 2, 130, 2, 3, 3, 3, 130, 
+	130, 3, 2, 130, 2, 130, 2, 3, 
+	3, 3, 3, 130, 130, 3, 130, 2, 
+	3, 130, 130, 3, 130, 3, 2, 3, 
+	130, 3, 130, 2, 3, 130, 130, 130, 
+	130, 3, 130, 2, 130, 130, 2, 181, 
+	182, 183, 184, 185, 2, 130, 58, 2, 
+	130, 2, 130, 2, 130, 2, 130, 2, 
+	186, 187, 2, 130, 2, 130, 2, 188, 
+	189, 190, 191, 66, 192, 193, 194, 195, 
+	196, 197, 198, 199, 200, 201, 2, 130, 
+	130, 2, 130, 2, 130, 2, 130, 130, 
+	130, 3, 3, 130, 2, 130, 2, 130, 
+	2, 3, 130, 2, 130, 3, 2, 3, 
+	130, 130, 130, 3, 130, 3, 2, 130, 
+	2, 3, 130, 3, 130, 3, 130, 2, 
+	130, 130, 3, 130, 2, 130, 130, 130, 
+	130, 2, 130, 3, 3, 130, 130, 3, 
+	2, 130, 130, 3, 130, 3, 2, 202, 
+	203, 189, 2, 130, 2, 130, 130, 2, 
+	204, 205, 206, 207, 208, 209, 210, 2, 
+	211, 212, 213, 214, 215, 2, 130, 2, 
+	130, 2, 130, 2, 130, 130, 130, 130, 
+	130, 2, 130, 2, 216, 217, 218, 219, 
+	220, 221, 222, 223, 224, 225, 226, 227, 
+	228, 229, 230, 231, 232, 233, 234, 235, 
+	236, 237, 238, 2, 130, 3, 130, 2, 
+	2, 130, 3, 2, 3, 3, 2, 130, 
+	3, 130, 130, 2, 130, 2, 3, 130, 
+	3, 130, 3, 2, 2, 130, 2, 3, 
+	130, 130, 3, 130, 3, 130, 2, 130, 
+	3, 130, 2, 130, 130, 3, 130, 3, 
+	2, 130, 130, 3, 3, 3, 3, 130, 
+	130, 2, 3, 130, 2, 3, 3, 130, 
+	2, 130, 3, 130, 3, 130, 3, 130, 
+	2, 3, 2, 130, 130, 3, 3, 130, 
+	3, 130, 2, 2, 2, 130, 130, 3, 
+	130, 3, 130, 2, 2, 130, 3, 3, 
+	130, 3, 130, 2, 3, 130, 3, 130, 
+	2, 3, 3, 130, 130, 2, 3, 3, 
+	3, 130, 130, 2, 239, 240, 115, 241, 
+	2, 130, 2, 130, 2, 130, 2, 242, 
+	2, 130, 2, 243, 244, 245, 246, 247, 
+	248, 2, 3, 3, 130, 130, 130, 2, 
+	2, 2, 2, 130, 130, 2, 130, 130, 
+	2, 2, 2, 130, 130, 130, 130, 2, 
+	249, 250, 251, 2, 130, 130, 130, 130, 
+	130, 2, 130, 2, 130, 2, 252, 2, 
+	3, 2, 253, 2, 254, 255, 256, 258, 
+	257, 2, 130, 2, 2, 130, 130, 3, 
+	2, 3, 2, 259, 2, 260, 261, 262, 
+	264, 263, 2, 3, 2, 2, 3, 3, 
+	79, 80, 81, 82, 83, 84, 2, 3, 
+	1, 265, 265, 3, 1, 265, 266, 3, 
+	1, 267, 268, 267, 268, 268, 267, 268, 
+	268, 267, 268, 268, 268, 267, 268, 267, 
+	268, 268, 267, 268, 268, 268, 268, 267, 
+	268, 268, 267, 267, 268, 268, 267, 268, 
+	267, 269, 270, 271, 272, 273, 275, 276, 
+	277, 279, 280, 281, 282, 283, 284, 285, 
+	286, 287, 288, 289, 290, 291, 292, 293, 
+	294, 295, 296, 274, 278, 267, 268, 268, 
+	268, 268, 267, 268, 267, 268, 268, 267, 
+	267, 267, 268, 267, 267, 267, 268, 268, 
+	268, 268, 267, 267, 267, 267, 267, 267, 
+	268, 267, 267, 267, 267, 267, 267, 268, 
+	267, 267, 267, 267, 268, 268, 268, 268, 
+	267, 268, 268, 268, 268, 268, 267, 268, 
+	268, 267, 268, 268, 268, 268, 267, 268, 
+	268, 267, 267, 267, 267, 267, 267, 268, 
+	268, 268, 268, 268, 268, 267, 268, 268, 
+	267, 267, 267, 267, 267, 267, 268, 268, 
+	267, 268, 268, 268, 268, 268, 267, 268, 
+	268, 267, 268, 267, 268, 268, 268, 267, 
+	268, 267, 268, 268, 268, 268, 268, 267, 
+	268, 267, 268, 268, 268, 268, 267, 268, 
+	267, 297, 298, 299, 300, 301, 302, 303, 
+	304, 305, 306, 307, 308, 309, 310, 311, 
+	312, 313, 314, 315, 316, 317, 267, 268, 
+	268, 267, 268, 268, 268, 267, 268, 268, 
+	268, 268, 267, 268, 267, 268, 268, 267, 
+	268, 268, 267, 268, 267, 267, 267, 268, 
+	268, 267, 268, 268, 267, 268, 268, 267, 
+	268, 267, 268, 268, 268, 268, 268, 267, 
+	268, 267, 268, 268, 267, 267, 267, 268, 
+	268, 268, 267, 268, 267, 268, 267, 268, 
+	268, 268, 268, 268, 267, 268, 268, 267, 
+	318, 319, 320, 321, 322, 267, 268, 323, 
+	267, 318, 319, 324, 320, 321, 322, 267, 
+	268, 267, 268, 267, 268, 267, 268, 267, 
+	268, 267, 325, 326, 267, 268, 267, 268, 
+	267, 327, 328, 329, 330, 331, 332, 333, 
+	334, 335, 336, 337, 338, 339, 340, 341, 
+	267, 268, 268, 267, 268, 267, 268, 267, 
+	268, 268, 268, 268, 267, 268, 268, 267, 
+	267, 267, 268, 268, 267, 268, 267, 268, 
+	268, 267, 267, 267, 268, 268, 267, 268, 
+	268, 268, 267, 268, 268, 268, 268, 267, 
+	268, 268, 268, 267, 268, 268, 267, 342, 
+	343, 328, 267, 268, 267, 268, 268, 267, 
+	344, 345, 346, 347, 348, 349, 350, 267, 
+	351, 352, 353, 354, 355, 267, 268, 267, 
+	268, 267, 268, 267, 268, 268, 268, 268, 
+	268, 267, 268, 267, 356, 357, 358, 359, 
+	360, 361, 362, 363, 364, 365, 366, 367, 
+	368, 369, 370, 371, 372, 369, 373, 374, 
+	375, 376, 377, 267, 268, 268, 267, 267, 
+	268, 267, 267, 268, 268, 268, 267, 268, 
+	267, 268, 268, 267, 267, 267, 268, 268, 
+	268, 267, 268, 267, 268, 268, 268, 267, 
+	268, 268, 268, 268, 268, 268, 268, 267, 
+	268, 267, 268, 267, 268, 267, 267, 268, 
+	268, 268, 267, 267, 267, 268, 267, 268, 
+	268, 267, 268, 267, 268, 268, 267, 268, 
+	268, 267, 378, 379, 380, 381, 267, 268, 
+	267, 268, 267, 268, 267, 268, 267, 382, 
+	267, 268, 267, 383, 384, 385, 386, 387, 
+	388, 267, 268, 268, 268, 267, 267, 267, 
+	267, 268, 268, 267, 268, 268, 267, 267, 
+	267, 268, 268, 268, 268, 267, 389, 390, 
+	391, 267, 268, 268, 268, 268, 268, 267, 
+	268, 267, 268, 267, 392, 393, 394, 267, 
+	395, 267, 395, 267, 267, 395, 395, 267, 
+	395, 395, 267, 395, 395, 395, 267, 395, 
+	267, 395, 395, 267, 395, 395, 395, 395, 
+	267, 395, 395, 267, 267, 395, 395, 267, 
+	395, 267, 396, 397, 398, 399, 400, 401, 
+	402, 404, 405, 406, 407, 408, 409, 410, 
+	411, 412, 413, 414, 415, 287, 416, 417, 
+	418, 419, 420, 421, 422, 423, 424, 403, 
+	267, 395, 395, 395, 395, 267, 395, 267, 
+	395, 395, 267, 268, 268, 267, 267, 268, 
+	395, 395, 267, 395, 395, 267, 395, 267, 
+	268, 395, 395, 395, 268, 268, 267, 395, 
+	395, 395, 267, 267, 267, 395, 267, 268, 
+	268, 395, 395, 268, 267, 395, 395, 395, 
+	267, 395, 267, 395, 267, 395, 267, 268, 
+	267, 267, 395, 395, 267, 395, 267, 268, 
+	395, 395, 268, 395, 267, 268, 395, 395, 
+	268, 268, 395, 395, 267, 395, 395, 268, 
+	267, 395, 395, 395, 268, 268, 268, 267, 
+	395, 268, 395, 267, 267, 267, 268, 267, 
+	267, 267, 395, 395, 395, 268, 395, 268, 
+	267, 395, 395, 268, 268, 268, 395, 395, 
+	395, 267, 395, 395, 268, 268, 267, 267, 
+	267, 395, 395, 395, 267, 395, 267, 268, 
+	395, 395, 395, 395, 268, 395, 268, 268, 
+	267, 395, 268, 395, 267, 395, 267, 395, 
+	268, 395, 395, 267, 395, 267, 395, 395, 
+	395, 395, 268, 267, 268, 395, 267, 395, 
+	395, 395, 395, 267, 395, 267, 425, 426, 
+	427, 428, 429, 430, 431, 432, 433, 434, 
+	435, 436, 437, 438, 439, 440, 441, 442, 
+	443, 444, 445, 267, 268, 395, 395, 268, 
+	395, 267, 268, 395, 395, 395, 267, 395, 
+	268, 395, 395, 395, 267, 395, 267, 395, 
+	395, 267, 395, 395, 267, 268, 395, 268, 
+	267, 395, 395, 395, 267, 268, 395, 267, 
+	395, 395, 267, 395, 395, 268, 395, 268, 
+	268, 395, 267, 395, 395, 268, 267, 395, 
+	395, 395, 395, 268, 395, 395, 268, 395, 
+	267, 395, 267, 268, 268, 268, 395, 395, 
+	268, 267, 395, 267, 395, 267, 268, 268, 
+	268, 268, 395, 395, 268, 395, 267, 268, 
+	395, 395, 268, 395, 268, 267, 268, 395, 
+	268, 395, 267, 268, 395, 395, 395, 395, 
+	268, 395, 267, 395, 395, 267, 446, 447, 
+	448, 449, 450, 267, 395, 323, 267, 395, 
+	267, 395, 267, 395, 267, 395, 267, 451, 
+	452, 267, 395, 267, 395, 267, 453, 454, 
+	455, 456, 331, 457, 458, 459, 460, 461, 
+	462, 463, 464, 465, 466, 267, 395, 395, 
+	267, 395, 267, 395, 267, 395, 395, 395, 
+	268, 268, 395, 267, 395, 267, 395, 267, 
+	268, 395, 267, 395, 268, 267, 268, 395, 
+	395, 395, 268, 395, 268, 267, 395, 267, 
+	268, 395, 268, 395, 268, 395, 267, 395, 
+	395, 268, 395, 267, 395, 395, 395, 395, 
+	267, 395, 268, 268, 395, 395, 268, 267, 
+	395, 395, 268, 395, 268, 267, 467, 468, 
+	454, 267, 395, 267, 395, 395, 267, 469, 
+	470, 471, 472, 473, 474, 475, 267, 476, 
+	477, 478, 479, 480, 267, 395, 267, 395, 
+	267, 395, 267, 395, 395, 395, 395, 395, 
+	267, 395, 267, 481, 482, 483, 484, 485, 
+	486, 487, 488, 489, 490, 491, 492, 493, 
+	494, 495, 496, 497, 498, 499, 500, 501, 
+	502, 503, 267, 395, 268, 395, 267, 267, 
+	395, 268, 267, 268, 268, 267, 395, 268, 
+	395, 395, 267, 395, 267, 268, 395, 268, 
+	395, 268, 267, 267, 395, 267, 268, 395, 
+	395, 268, 395, 268, 395, 267, 395, 268, 
+	395, 267, 395, 395, 268, 395, 268, 267, 
+	395, 395, 268, 268, 268, 268, 395, 395, 
+	267, 268, 395, 267, 268, 268, 395, 267, 
+	395, 268, 395, 268, 395, 268, 395, 267, 
+	268, 267, 395, 395, 268, 268, 395, 268, 
+	395, 267, 267, 267, 395, 395, 268, 395, 
+	268, 395, 267, 267, 395, 268, 268, 395, 
+	268, 395, 267, 268, 395, 268, 395, 267, 
+	268, 268, 395, 395, 267, 268, 268, 268, 
+	395, 395, 267, 504, 505, 380, 506, 267, 
+	395, 267, 395, 267, 395, 267, 507, 267, 
+	395, 267, 508, 509, 510, 511, 512, 513, 
+	267, 268, 268, 395, 395, 395, 267, 267, 
+	267, 267, 395, 395, 267, 395, 395, 267, 
+	267, 267, 395, 395, 395, 395, 267, 514, 
+	515, 516, 267, 395, 395, 395, 395, 395, 
+	267, 395, 267, 395, 267, 517, 267, 268, 
+	267, 518, 267, 519, 520, 521, 523, 522, 
+	267, 395, 267, 267, 395, 395, 268, 267, 
+	268, 267, 524, 267, 525, 526, 527, 529, 
+	528, 267, 268, 267, 267, 268, 268, 344, 
+	345, 346, 347, 348, 349, 267, 268, 267, 
+	268, 268, 267, 266, 268, 268, 267, 266, 
+	268, 267, 266, 268, 267, 531, 532, 530, 
+	267, 266, 268, 267, 266, 268, 267, 533, 
+	534, 535, 536, 537, 530, 267, 538, 267, 
+	297, 298, 299, 533, 534, 539, 300, 301, 
+	302, 303, 304, 305, 306, 307, 308, 309, 
+	310, 311, 312, 313, 314, 315, 316, 317, 
+	267, 540, 538, 297, 298, 299, 541, 535, 
+	536, 300, 301, 302, 303, 304, 305, 306, 
+	307, 308, 309, 310, 311, 312, 313, 314, 
+	315, 316, 317, 267, 540, 267, 542, 540, 
+	297, 298, 299, 543, 536, 300, 301, 302, 
+	303, 304, 305, 306, 307, 308, 309, 310, 
+	311, 312, 313, 314, 315, 316, 317, 267, 
+	542, 267, 267, 542, 544, 267, 542, 267, 
+	545, 546, 267, 540, 267, 267, 542, 267, 
+	540, 267, 540, 327, 328, 329, 330, 331, 
+	332, 333, 547, 335, 336, 337, 338, 339, 
+	340, 341, 549, 550, 551, 552, 553, 554, 
+	549, 550, 551, 552, 553, 554, 549, 548, 
+	555, 267, 268, 538, 267, 556, 556, 556, 
+	542, 267, 297, 298, 299, 541, 539, 300, 
+	301, 302, 303, 304, 305, 306, 307, 308, 
+	309, 310, 311, 312, 313, 314, 315, 316, 
+	317, 267, 545, 557, 267, 267, 540, 556, 
+	556, 542, 556, 556, 542, 556, 556, 556, 
+	542, 556, 556, 542, 556, 556, 542, 556, 
+	556, 267, 542, 542, 551, 552, 553, 554, 
+	548, 549, 551, 552, 553, 554, 548, 549, 
+	551, 552, 553, 554, 548, 549, 551, 552, 
+	553, 554, 548, 549, 551, 552, 553, 554, 
+	548, 549, 551, 552, 553, 554, 548, 549, 
+	551, 552, 553, 554, 548, 549, 551, 552, 
+	553, 554, 548, 549, 551, 552, 553, 554, 
+	548, 549, 550, 555, 552, 553, 554, 548, 
+	549, 550, 552, 553, 554, 548, 549, 550, 
+	552, 553, 554, 548, 549, 550, 552, 553, 
+	554, 548, 549, 550, 552, 553, 554, 548, 
+	549, 550, 552, 553, 554, 548, 549, 550, 
+	552, 553, 554, 548, 549, 550, 552, 553, 
+	554, 548, 549, 550, 552, 553, 554, 548, 
+	549, 550, 551, 555, 553, 554, 548, 549, 
+	550, 551, 553, 554, 548, 549, 550, 551, 
+	553, 554, 548, 549, 550, 551, 553, 554, 
+	548, 549, 550, 551, 553, 558, 557, 552, 
+	267, 555, 556, 267, 540, 542, 268, 268, 
+	267, 559, 560, 561, 562, 563, 530, 267, 
+	268, 323, 268, 268, 268, 267, 268, 268, 
+	267, 395, 268, 267, 395, 268, 267, 268, 
+	395, 268, 267, 530, 267, 564, 566, 567, 
+	568, 569, 570, 571, 566, 567, 568, 569, 
+	570, 571, 566, 530, 565, 555, 267, 268, 
+	538, 268, 267, 540, 540, 540, 542, 267, 
+	540, 540, 542, 540, 540, 542, 540, 540, 
+	540, 542, 540, 540, 542, 540, 540, 542, 
+	540, 540, 267, 542, 568, 569, 570, 571, 
+	565, 566, 568, 569, 570, 571, 565, 566, 
+	568, 569, 570, 571, 565, 566, 568, 569, 
+	570, 571, 565, 566, 568, 569, 570, 571, 
+	565, 566, 568, 569, 570, 571, 565, 566, 
+	568, 569, 570, 571, 565, 566, 568, 569, 
+	570, 571, 565, 566, 568, 569, 570, 571, 
+	565, 566, 567, 555, 569, 570, 571, 565, 
+	566, 567, 569, 570, 571, 565, 566, 567, 
+	569, 570, 571, 565, 566, 567, 569, 570, 
+	571, 565, 566, 567, 569, 570, 571, 565, 
+	566, 567, 569, 570, 571, 565, 566, 567, 
+	569, 570, 571, 565, 566, 567, 569, 570, 
+	571, 565, 566, 567, 569, 570, 571, 565, 
+	566, 567, 568, 555, 570, 571, 565, 566, 
+	567, 568, 570, 571, 565, 566, 567, 568, 
+	570, 571, 565, 566, 567, 568, 570, 571, 
+	565, 566, 567, 568, 570, 572, 573, 569, 
+	267, 555, 540, 268, 540, 542, 268, 542, 
+	268, 267, 540, 574, 575, 530, 267, 268, 
+	267, 268, 268, 268, 267, 577, 578, 579, 
+	580, 576, 267, 581, 582, 530, 267, 266, 
+	268, 267, 268, 266, 268, 267, 583, 530, 
+	267, 268, 268, 267, 584, 530, 267, 268, 
+	268, 267, 585, 586, 587, 588, 589, 590, 
+	591, 592, 593, 594, 595, 530, 267, 268, 
+	596, 267, 344, 345, 346, 347, 348, 349, 
+	597, 267, 598, 267, 268, 267, 395, 268, 
+	267, 268, 395, 268, 395, 268, 267, 395, 
+	395, 268, 395, 268, 395, 268, 395, 268, 
+	395, 268, 267, 268, 268, 395, 395, 268, 
+	267, 395, 395, 268, 267, 395, 268, 395, 
+	268, 267, 268, 395, 268, 395, 268, 267, 
+	395, 268, 395, 268, 267, 395, 268, 267, 
+	395, 395, 268, 268, 395, 268, 395, 268, 
+	395, 267, 576, 267, 599, 576, 267, 322, 
+	530, 600, 530, 267, 268, 267, 266, 3, 
+	1, 266, 3, 1, 602, 603, 601, 1, 
+	266, 3, 1, 266, 3, 1, 604, 605, 
+	606, 607, 608, 601, 1, 609, 610, 612, 
+	611, 611, 612, 612, 611, 612, 612, 611, 
+	612, 612, 612, 611, 612, 611, 612, 612, 
+	611, 612, 612, 612, 612, 611, 612, 612, 
+	611, 611, 612, 612, 611, 612, 611, 613, 
+	614, 615, 616, 617, 619, 620, 621, 623, 
+	624, 625, 626, 627, 628, 629, 630, 631, 
+	632, 633, 634, 635, 636, 637, 638, 639, 
+	640, 618, 622, 611, 612, 612, 612, 612, 
+	611, 612, 611, 612, 612, 611, 611, 611, 
+	612, 611, 611, 611, 612, 612, 612, 612, 
+	611, 611, 611, 611, 611, 611, 612, 611, 
+	611, 611, 611, 611, 611, 612, 611, 611, 
+	611, 611, 612, 612, 612, 612, 611, 612, 
+	612, 612, 612, 612, 611, 612, 612, 611, 
+	612, 612, 612, 612, 611, 612, 612, 611, 
+	611, 611, 611, 611, 611, 612, 612, 612, 
+	612, 612, 612, 611, 612, 612, 611, 611, 
+	611, 611, 611, 611, 612, 612, 611, 612, 
+	612, 612, 612, 612, 611, 612, 612, 611, 
+	612, 611, 612, 612, 612, 611, 612, 611, 
+	612, 612, 612, 612, 612, 611, 612, 611, 
+	612, 612, 612, 612, 611, 612, 611, 641, 
+	642, 643, 644, 645, 646, 647, 648, 649, 
+	650, 651, 652, 653, 654, 655, 656, 657, 
+	658, 659, 660, 661, 611, 612, 612, 611, 
+	612, 612, 612, 611, 612, 612, 612, 612, 
+	611, 612, 611, 612, 612, 611, 612, 612, 
+	611, 612, 611, 611, 611, 612, 612, 611, 
+	612, 612, 611, 612, 612, 611, 612, 611, 
+	612, 612, 612, 612, 612, 611, 612, 611, 
+	612, 612, 611, 611, 611, 612, 612, 612, 
+	611, 612, 611, 612, 611, 612, 612, 612, 
+	612, 612, 611, 612, 612, 611, 662, 663, 
+	664, 665, 666, 611, 612, 667, 611, 662, 
+	663, 668, 664, 665, 666, 611, 612, 611, 
+	612, 611, 612, 611, 612, 611, 612, 611, 
+	669, 670, 611, 612, 611, 612, 611, 671, 
+	672, 673, 674, 675, 676, 677, 678, 679, 
+	680, 681, 682, 683, 684, 685, 611, 612, 
+	612, 611, 612, 611, 612, 611, 612, 612, 
+	612, 612, 611, 612, 612, 611, 611, 611, 
+	612, 612, 611, 612, 611, 612, 612, 611, 
+	611, 611, 612, 612, 611, 612, 612, 612, 
+	611, 612, 612, 612, 612, 611, 612, 612, 
+	612, 611, 612, 612, 611, 686, 687, 672, 
+	611, 612, 611, 612, 612, 611, 688, 689, 
+	690, 691, 692, 693, 694, 611, 695, 696, 
+	697, 698, 699, 611, 612, 611, 612, 611, 
+	612, 611, 612, 612, 612, 612, 612, 611, 
+	612, 611, 700, 701, 702, 703, 704, 705, 
+	706, 707, 708, 709, 710, 711, 712, 713, 
+	714, 715, 716, 713, 717, 718, 719, 720, 
+	721, 611, 612, 612, 611, 611, 612, 611, 
+	611, 612, 612, 612, 611, 612, 611, 612, 
+	612, 611, 611, 611, 612, 612, 612, 611, 
+	612, 611, 612, 612, 612, 611, 612, 612, 
+	612, 612, 612, 612, 612, 611, 612, 611, 
+	612, 611, 612, 611, 611, 612, 612, 612, 
+	611, 611, 611, 612, 611, 612, 612, 611, 
+	612, 611, 612, 612, 611, 612, 612, 611, 
+	722, 723, 724, 725, 611, 612, 611, 612, 
+	611, 612, 611, 612, 611, 726, 611, 612, 
+	611, 727, 728, 729, 730, 731, 732, 611, 
+	612, 612, 612, 611, 611, 611, 611, 612, 
+	612, 611, 612, 612, 611, 611, 611, 612, 
+	612, 612, 612, 611, 733, 734, 735, 611, 
+	612, 612, 612, 612, 612, 611, 612, 611, 
+	612, 611, 736, 737, 738, 611, 739, 611, 
+	739, 611, 611, 739, 739, 611, 739, 739, 
+	611, 739, 739, 739, 611, 739, 611, 739, 
+	739, 611, 739, 739, 739, 739, 611, 739, 
+	739, 611, 611, 739, 739, 611, 739, 611, 
+	740, 741, 742, 743, 744, 745, 746, 748, 
+	749, 750, 751, 752, 753, 754, 755, 756, 
+	757, 758, 759, 631, 760, 761, 762, 763, 
+	764, 765, 766, 767, 768, 747, 611, 739, 
+	739, 739, 739, 611, 739, 611, 739, 739, 
+	611, 612, 612, 611, 611, 612, 739, 739, 
+	611, 739, 739, 611, 739, 611, 612, 739, 
+	739, 739, 612, 612, 611, 739, 739, 739, 
+	611, 611, 611, 739, 611, 612, 612, 739, 
+	739, 612, 611, 739, 739, 739, 611, 739, 
+	611, 739, 611, 739, 611, 612, 611, 611, 
+	739, 739, 611, 739, 611, 612, 739, 739, 
+	612, 739, 611, 612, 739, 739, 612, 612, 
+	739, 739, 611, 739, 739, 612, 611, 739, 
+	739, 739, 612, 612, 612, 611, 739, 612, 
+	739, 611, 611, 611, 612, 611, 611, 611, 
+	739, 739, 739, 612, 739, 612, 611, 739, 
+	739, 612, 612, 612, 739, 739, 739, 611, 
+	739, 739, 612, 612, 611, 611, 611, 739, 
+	739, 739, 611, 739, 611, 612, 739, 739, 
+	739, 739, 612, 739, 612, 612, 611, 739, 
+	612, 739, 611, 739, 611, 739, 612, 739, 
+	739, 611, 739, 611, 739, 739, 739, 739, 
+	612, 611, 612, 739, 611, 739, 739, 739, 
+	739, 611, 739, 611, 769, 770, 771, 772, 
+	773, 774, 775, 776, 777, 778, 779, 780, 
+	781, 782, 783, 784, 785, 786, 787, 788, 
+	789, 611, 612, 739, 739, 612, 739, 611, 
+	612, 739, 739, 739, 611, 739, 612, 739, 
+	739, 739, 611, 739, 611, 739, 739, 611, 
+	739, 739, 611, 612, 739, 612, 611, 739, 
+	739, 739, 611, 612, 739, 611, 739, 739, 
+	611, 739, 739, 612, 739, 612, 612, 739, 
+	611, 739, 739, 612, 611, 739, 739, 739, 
+	739, 612, 739, 739, 612, 739, 611, 739, 
+	611, 612, 612, 612, 739, 739, 612, 611, 
+	739, 611, 739, 611, 612, 612, 612, 612, 
+	739, 739, 612, 739, 611, 612, 739, 739, 
+	612, 739, 612, 611, 612, 739, 612, 739, 
+	611, 612, 739, 739, 739, 739, 612, 739, 
+	611, 739, 739, 611, 790, 791, 792, 793, 
+	794, 611, 739, 667, 611, 739, 611, 739, 
+	611, 739, 611, 739, 611, 795, 796, 611, 
+	739, 611, 739, 611, 797, 798, 799, 800, 
+	675, 801, 802, 803, 804, 805, 806, 807, 
+	808, 809, 810, 611, 739, 739, 611, 739, 
+	611, 739, 611, 739, 739, 739, 612, 612, 
+	739, 611, 739, 611, 739, 611, 612, 739, 
+	611, 739, 612, 611, 612, 739, 739, 739, 
+	612, 739, 612, 611, 739, 611, 612, 739, 
+	612, 739, 612, 739, 611, 739, 739, 612, 
+	739, 611, 739, 739, 739, 739, 611, 739, 
+	612, 612, 739, 739, 612, 611, 739, 739, 
+	612, 739, 612, 611, 811, 812, 798, 611, 
+	739, 611, 739, 739, 611, 813, 814, 815, 
+	816, 817, 818, 819, 611, 820, 821, 822, 
+	823, 824, 611, 739, 611, 739, 611, 739, 
+	611, 739, 739, 739, 739, 739, 611, 739, 
+	611, 825, 826, 827, 828, 829, 830, 831, 
+	832, 833, 834, 835, 836, 837, 838, 839, 
+	840, 841, 842, 843, 844, 845, 846, 847, 
+	611, 739, 612, 739, 611, 611, 739, 612, 
+	611, 612, 612, 611, 739, 612, 739, 739, 
+	611, 739, 611, 612, 739, 612, 739, 612, 
+	611, 611, 739, 611, 612, 739, 739, 612, 
+	739, 612, 739, 611, 739, 612, 739, 611, 
+	739, 739, 612, 739, 612, 611, 739, 739, 
+	612, 612, 612, 612, 739, 739, 611, 612, 
+	739, 611, 612, 612, 739, 611, 739, 612, 
+	739, 612, 739, 612, 739, 611, 612, 611, 
+	739, 739, 612, 612, 739, 612, 739, 611, 
+	611, 611, 739, 739, 612, 739, 612, 739, 
+	611, 611, 739, 612, 612, 739, 612, 739, 
+	611, 612, 739, 612, 739, 611, 612, 612, 
+	739, 739, 611, 612, 612, 612, 739, 739, 
+	611, 848, 849, 724, 850, 611, 739, 611, 
+	739, 611, 739, 611, 851, 611, 739, 611, 
+	852, 853, 854, 855, 856, 857, 611, 612, 
+	612, 739, 739, 739, 611, 611, 611, 611, 
+	739, 739, 611, 739, 739, 611, 611, 611, 
+	739, 739, 739, 739, 611, 858, 859, 860, 
+	611, 739, 739, 739, 739, 739, 611, 739, 
+	611, 739, 611, 861, 611, 612, 611, 862, 
+	611, 863, 864, 865, 867, 866, 611, 739, 
+	611, 611, 739, 739, 612, 611, 612, 611, 
+	868, 611, 869, 870, 871, 873, 872, 611, 
+	612, 611, 611, 612, 612, 688, 689, 690, 
+	691, 692, 693, 611, 641, 642, 643, 604, 
+	605, 874, 644, 645, 646, 647, 648, 649, 
+	650, 651, 652, 653, 654, 655, 656, 657, 
+	658, 659, 660, 661, 611, 875, 610, 641, 
+	642, 643, 876, 606, 607, 644, 645, 646, 
+	647, 648, 649, 650, 651, 652, 653, 654, 
+	655, 656, 657, 658, 659, 660, 661, 611, 
+	875, 611, 877, 875, 641, 642, 643, 878, 
+	607, 644, 645, 646, 647, 648, 649, 650, 
+	651, 652, 653, 654, 655, 656, 657, 658, 
+	659, 660, 661, 611, 877, 611, 609, 877, 
+	879, 611, 877, 611, 880, 881, 611, 875, 
+	611, 611, 877, 611, 875, 611, 875, 671, 
+	672, 673, 674, 675, 676, 677, 882, 679, 
+	680, 681, 682, 683, 684, 685, 884, 885, 
+	886, 887, 888, 889, 884, 885, 886, 887, 
+	888, 889, 884, 883, 890, 611, 612, 610, 
+	611, 891, 891, 891, 877, 611, 641, 642, 
+	643, 876, 874, 644, 645, 646, 647, 648, 
+	649, 650, 651, 652, 653, 654, 655, 656, 
+	657, 658, 659, 660, 661, 611, 880, 892, 
+	611, 611, 875, 891, 891, 877, 891, 891, 
+	877, 891, 891, 891, 877, 891, 891, 877, 
+	891, 891, 877, 891, 891, 611, 877, 877, 
+	886, 887, 888, 889, 883, 884, 886, 887, 
+	888, 889, 883, 884, 886, 887, 888, 889, 
+	883, 884, 886, 887, 888, 889, 883, 884, 
+	886, 887, 888, 889, 883, 884, 886, 887, 
+	888, 889, 883, 884, 886, 887, 888, 889, 
+	883, 884, 886, 887, 888, 889, 883, 884, 
+	886, 887, 888, 889, 883, 884, 885, 890, 
+	887, 888, 889, 883, 884, 885, 887, 888, 
+	889, 883, 884, 885, 887, 888, 889, 883, 
+	884, 885, 887, 888, 889, 883, 884, 885, 
+	887, 888, 889, 883, 884, 885, 887, 888, 
+	889, 883, 884, 885, 887, 888, 889, 883, 
+	884, 885, 887, 888, 889, 883, 884, 885, 
+	887, 888, 889, 883, 884, 885, 886, 890, 
+	888, 889, 883, 884, 885, 886, 888, 889, 
+	883, 884, 885, 886, 888, 889, 883, 884, 
+	885, 886, 888, 889, 883, 884, 885, 886, 
+	888, 893, 892, 887, 611, 890, 891, 611, 
+	875, 877, 265, 3, 1, 894, 895, 896, 
+	897, 898, 601, 1, 265, 899, 3, 265, 
+	3, 265, 3, 1, 901, 900, 900, 901, 
+	901, 900, 901, 901, 900, 901, 901, 901, 
+	900, 901, 900, 901, 901, 900, 901, 901, 
+	901, 901, 900, 901, 901, 900, 900, 901, 
+	901, 900, 901, 900, 902, 903, 904, 905, 
+	906, 908, 909, 910, 912, 913, 914, 915, 
+	916, 917, 918, 919, 920, 921, 922, 923, 
+	924, 925, 926, 927, 928, 929, 907, 911, 
+	900, 901, 901, 901, 901, 900, 901, 900, 
+	901, 901, 900, 900, 900, 901, 900, 900, 
+	900, 901, 901, 901, 901, 900, 900, 900, 
+	900, 900, 900, 901, 900, 900, 900, 900, 
+	900, 900, 901, 900, 900, 900, 900, 901, 
+	901, 901, 901, 900, 901, 901, 901, 901, 
+	901, 900, 901, 901, 900, 901, 901, 901, 
+	901, 900, 901, 901, 900, 900, 900, 900, 
+	900, 900, 901, 901, 901, 901, 901, 901, 
+	900, 901, 901, 900, 900, 900, 900, 900, 
+	900, 901, 901, 900, 901, 901, 901, 901, 
+	901, 900, 901, 901, 900, 901, 900, 901, 
+	901, 901, 900, 901, 900, 901, 901, 901, 
+	901, 901, 900, 901, 900, 901, 901, 901, 
+	901, 900, 901, 900, 930, 931, 932, 933, 
+	934, 935, 936, 937, 938, 939, 940, 941, 
+	942, 943, 944, 945, 946, 947, 948, 949, 
+	950, 900, 901, 901, 900, 901, 901, 901, 
+	900, 901, 901, 901, 901, 900, 901, 900, 
+	901, 901, 900, 901, 901, 900, 901, 900, 
+	900, 900, 901, 901, 900, 901, 901, 900, 
+	901, 901, 900, 901, 900, 901, 901, 901, 
+	901, 901, 900, 901, 900, 901, 901, 900, 
+	900, 900, 901, 901, 901, 900, 901, 900, 
+	901, 900, 901, 901, 901, 901, 901, 900, 
+	901, 901, 900, 951, 952, 953, 954, 955, 
+	900, 901, 899, 900, 901, 900, 901, 900, 
+	901, 900, 901, 900, 956, 957, 900, 901, 
+	900, 901, 900, 958, 959, 960, 961, 962, 
+	963, 964, 965, 966, 967, 968, 969, 970, 
+	971, 972, 900, 901, 901, 900, 901, 900, 
+	901, 900, 901, 901, 901, 901, 900, 901, 
+	901, 900, 900, 900, 901, 901, 900, 901, 
+	900, 901, 901, 900, 900, 900, 901, 901, 
+	900, 901, 901, 901, 900, 901, 901, 901, 
+	901, 900, 901, 901, 901, 900, 901, 901, 
+	900, 973, 974, 959, 900, 901, 900, 901, 
+	901, 900, 975, 976, 977, 978, 979, 980, 
+	900, 981, 982, 983, 984, 985, 900, 901, 
+	900, 901, 900, 901, 900, 901, 901, 901, 
+	901, 901, 900, 901, 900, 986, 987, 988, 
+	989, 990, 991, 992, 993, 994, 995, 996, 
+	997, 998, 999, 1000, 1001, 1002, 999, 1003, 
+	1004, 1005, 1006, 1007, 900, 901, 901, 900, 
+	900, 901, 900, 900, 901, 901, 901, 900, 
+	901, 900, 901, 901, 900, 900, 900, 901, 
+	901, 901, 900, 901, 900, 901, 901, 901, 
+	900, 901, 901, 901, 901, 901, 901, 901, 
+	900, 901, 900, 901, 900, 901, 900, 900, 
+	901, 901, 901, 900, 900, 900, 901, 900, 
+	901, 901, 900, 901, 900, 901, 901, 900, 
+	901, 901, 900, 1008, 1009, 1010, 1011, 900, 
+	901, 900, 901, 900, 901, 900, 901, 900, 
+	1012, 900, 901, 900, 1013, 1014, 1015, 1016, 
+	1017, 1018, 900, 901, 901, 901, 900, 900, 
+	900, 900, 901, 901, 900, 901, 901, 900, 
+	900, 900, 901, 901, 901, 901, 900, 1019, 
+	1020, 1021, 900, 901, 901, 901, 901, 901, 
+	900, 901, 900, 901, 900, 1022, 900, 1023, 
+	1024, 1025, 1027, 1026, 900, 901, 900, 900, 
+	901, 901, 951, 952, 1028, 953, 954, 955, 
+	900, 901, 900, 975, 976, 977, 978, 979, 
+	980, 1029, 900, 1030, 1031, 1032, 900, 1033, 
+	900, 1033, 900, 900, 1033, 1033, 900, 1033, 
+	1033, 900, 1033, 1033, 1033, 900, 1033, 900, 
+	1033, 1033, 900, 1033, 1033, 1033, 1033, 900, 
+	1033, 1033, 900, 900, 1033, 1033, 900, 1033, 
+	900, 1034, 1035, 1036, 1037, 1038, 1039, 1040, 
+	1042, 1043, 1044, 1045, 1046, 1047, 1048, 1049, 
+	1050, 1051, 1052, 1053, 920, 1054, 1055, 1056, 
+	1057, 1058, 1059, 1060, 1061, 1062, 1041, 900, 
+	1033, 1033, 1033, 1033, 900, 1033, 900, 1033, 
+	1033, 900, 901, 901, 900, 900, 901, 1033, 
+	1033, 900, 1033, 1033, 900, 1033, 900, 901, 
+	1033, 1033, 1033, 901, 901, 900, 1033, 1033, 
+	1033, 900, 900, 900, 1033, 900, 901, 901, 
+	1033, 1033, 901, 900, 1033, 1033, 1033, 900, 
+	1033, 900, 1033, 900, 1033, 900, 901, 900, 
+	900, 1033, 1033, 900, 1033, 900, 901, 1033, 
+	1033, 901, 1033, 900, 901, 1033, 1033, 901, 
+	901, 1033, 1033, 900, 1033, 1033, 901, 900, 
+	1033, 1033, 1033, 901, 901, 901, 900, 1033, 
+	901, 1033, 900, 900, 900, 901, 900, 900, 
+	900, 1033, 1033, 1033, 901, 1033, 901, 900, 
+	1033, 1033, 901, 901, 901, 1033, 1033, 1033, 
+	900, 1033, 1033, 901, 901, 900, 900, 900, 
+	1033, 1033, 1033, 900, 1033, 900, 901, 1033, 
+	1033, 1033, 1033, 901, 1033, 901, 901, 900, 
+	1033, 901, 1033, 900, 1033, 900, 1033, 901, 
+	1033, 1033, 900, 1033, 900, 1033, 1033, 1033, 
+	1033, 901, 900, 901, 1033, 900, 1033, 1033, 
+	1033, 1033, 900, 1033, 900, 1063, 1064, 1065, 
+	1066, 1067, 1068, 1069, 1070, 1071, 1072, 1073, 
+	1074, 1075, 1076, 1077, 1078, 1079, 1080, 1081, 
+	1082, 1083, 900, 901, 1033, 1033, 901, 1033, 
+	900, 901, 1033, 1033, 1033, 900, 1033, 901, 
+	1033, 1033, 1033, 900, 1033, 900, 1033, 1033, 
+	900, 1033, 1033, 900, 901, 1033, 901, 900, 
+	1033, 1033, 1033, 900, 901, 1033, 900, 1033, 
+	1033, 900, 1033, 1033, 901, 1033, 901, 901, 
+	1033, 900, 1033, 1033, 901, 900, 1033, 1033, 
+	1033, 1033, 901, 1033, 1033, 901, 1033, 900, 
+	1033, 900, 901, 901, 901, 1033, 1033, 901, 
+	900, 1033, 900, 1033, 900, 901, 901, 901, 
+	901, 1033, 1033, 901, 1033, 900, 901, 1033, 
+	1033, 901, 1033, 901, 900, 901, 1033, 901, 
+	1033, 900, 901, 1033, 1033, 1033, 1033, 901, 
+	1033, 900, 1033, 1033, 900, 1084, 1085, 1086, 
+	1087, 1088, 900, 1033, 899, 900, 1033, 900, 
+	1033, 900, 1033, 900, 1033, 900, 1089, 1090, 
+	900, 1033, 900, 1033, 900, 1091, 1092, 1093, 
+	1094, 962, 1095, 1096, 1097, 1098, 1099, 1100, 
+	1101, 1102, 1103, 1104, 900, 1033, 1033, 900, 
+	1033, 900, 1033, 900, 1033, 1033, 1033, 901, 
+	901, 1033, 900, 1033, 900, 1033, 900, 901, 
+	1033, 900, 1033, 901, 900, 901, 1033, 1033, 
+	1033, 901, 1033, 901, 900, 1033, 900, 901, 
+	1033, 901, 1033, 901, 1033, 900, 1033, 1033, 
+	901, 1033, 900, 1033, 1033, 1033, 1033, 900, 
+	1033, 901, 901, 1033, 1033, 901, 900, 1033, 
+	1033, 901, 1033, 901, 900, 1105, 1106, 1092, 
+	900, 1033, 900, 1033, 1033, 900, 1107, 1108, 
+	1109, 1110, 1111, 1112, 1113, 900, 1114, 1115, 
+	1116, 1117, 1118, 900, 1033, 900, 1033, 900, 
+	1033, 900, 1033, 1033, 1033, 1033, 1033, 900, 
+	1033, 900, 1119, 1120, 1121, 1122, 1123, 1124, 
+	1125, 1126, 1127, 1128, 1129, 1130, 1131, 1132, 
+	1133, 1134, 1135, 1136, 1137, 1138, 1139, 1140, 
+	1141, 900, 1033, 901, 1033, 900, 900, 1033, 
+	901, 900, 901, 901, 900, 1033, 901, 1033, 
+	1033, 900, 1033, 900, 901, 1033, 901, 1033, 
+	901, 900, 900, 1033, 900, 901, 1033, 1033, 
+	901, 1033, 901, 1033, 900, 1033, 901, 1033, 
+	900, 1033, 1033, 901, 1033, 901, 900, 1033, 
+	1033, 901, 901, 901, 901, 1033, 1033, 900, 
+	901, 1033, 900, 901, 901, 1033, 900, 1033, 
+	901, 1033, 901, 1033, 901, 1033, 900, 901, 
+	900, 1033, 1033, 901, 901, 1033, 901, 1033, 
+	900, 900, 900, 1033, 1033, 901, 1033, 901, 
+	1033, 900, 900, 1033, 901, 901, 1033, 901, 
+	1033, 900, 901, 1033, 901, 1033, 900, 901, 
+	901, 1033, 1033, 900, 901, 901, 901, 1033, 
+	1033, 900, 1142, 1143, 1010, 1144, 900, 1033, 
+	900, 1033, 900, 1033, 900, 1145, 900, 1033, 
+	900, 1146, 1147, 1148, 1149, 1150, 1151, 900, 
+	901, 901, 1033, 1033, 1033, 900, 900, 900, 
+	900, 1033, 1033, 900, 1033, 1033, 900, 900, 
+	900, 1033, 1033, 1033, 1033, 900, 1152, 1153, 
+	1154, 900, 1033, 1033, 1033, 1033, 1033, 900, 
+	1033, 900, 1033, 900, 1155, 900, 901, 900, 
+	1156, 900, 1157, 1158, 1159, 1161, 1160, 900, 
+	1033, 900, 900, 1033, 1033, 901, 900, 901, 
+	900, 3, 265, 3, 1, 1162, 3, 1, 
+	1162, 1163, 1163, 1162, 1162, 1163, 1162, 1162, 
+	1163, 1162, 1162, 1162, 1163, 1162, 1163, 1162, 
+	1162, 1163, 1162, 1162, 1162, 1162, 1163, 1162, 
+	1162, 1163, 1163, 1162, 1162, 1163, 1162, 1163, 
+	1164, 1165, 1166, 1167, 1168, 1169, 1170, 1172, 
+	1173, 1174, 1175, 1176, 1177, 1178, 1179, 1180, 
+	1181, 1182, 1183, 1184, 1185, 1186, 1187, 1188, 
+	1189, 1190, 1191, 1192, 1193, 1171, 1163, 1162, 
+	1162, 1162, 1162, 1163, 1162, 1163, 1162, 1162, 
+	1163, 1194, 1194, 1163, 1163, 1194, 1162, 1194, 
+	1163, 1163, 1194, 1194, 1163, 1194, 1194, 1163, 
+	1194, 1194, 1194, 1163, 1194, 1163, 1194, 1194, 
+	1163, 1194, 1194, 1194, 1194, 1163, 1194, 1194, 
+	1163, 1163, 1194, 1194, 1163, 1194, 1163, 1195, 
+	1196, 1197, 1198, 1199, 1201, 1202, 1203, 1205, 
+	1206, 1207, 1208, 1209, 1210, 1211, 1212, 1184, 
+	1213, 1214, 1215, 1216, 1217, 1218, 1219, 1220, 
+	1221, 1200, 1204, 1163, 1194, 1194, 1194, 1194, 
+	1163, 1194, 1163, 1194, 1194, 1163, 1163, 1163, 
+	1194, 1163, 1163, 1163, 1194, 1194, 1194, 1194, 
+	1163, 1163, 1163, 1163, 1163, 1163, 1194, 1163, 
+	1163, 1163, 1163, 1163, 1163, 1194, 1163, 1163, 
+	1163, 1163, 1194, 1194, 1194, 1194, 1163, 1194, 
+	1194, 1194, 1194, 1194, 1163, 1194, 1194, 1163, 
+	1194, 1194, 1194, 1194, 1163, 1194, 1194, 1163, 
+	1163, 1163, 1163, 1163, 1163, 1194, 1194, 1194, 
+	1194, 1194, 1194, 1163, 1194, 1194, 1163, 1163, 
+	1163, 1163, 1163, 1163, 1194, 1194, 1163, 1194, 
+	1194, 1194, 1194, 1194, 1163, 1194, 1194, 1163, 
+	1194, 1163, 1194, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1194, 1194, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1194, 1194, 1194, 1163, 1194, 1163, 1222, 
+	1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 
+	1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 
+	1239, 1240, 1241, 1242, 1163, 1194, 1194, 1163, 
+	1194, 1194, 1194, 1163, 1194, 1194, 1194, 1194, 
+	1163, 1194, 1163, 1194, 1194, 1163, 1194, 1194, 
+	1163, 1194, 1163, 1163, 1163, 1194, 1194, 1163, 
+	1194, 1194, 1163, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1194, 1194, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1194, 1163, 1163, 1163, 1194, 1194, 1194, 
+	1163, 1194, 1163, 1194, 1163, 1194, 1194, 1194, 
+	1194, 1194, 1163, 1194, 1194, 1163, 1243, 1244, 
+	1245, 1246, 1247, 1163, 1194, 1248, 1163, 1243, 
+	1244, 1249, 1245, 1246, 1247, 1163, 1194, 1163, 
+	1194, 1163, 1194, 1163, 1194, 1163, 1194, 1163, 
+	1250, 1251, 1163, 1194, 1163, 1194, 1163, 1252, 
+	1253, 1254, 1255, 1256, 1257, 1258, 1259, 1260, 
+	1261, 1262, 1263, 1264, 1265, 1266, 1163, 1194, 
+	1194, 1163, 1194, 1163, 1194, 1163, 1194, 1194, 
+	1194, 1194, 1163, 1194, 1194, 1163, 1163, 1163, 
+	1194, 1194, 1163, 1194, 1163, 1194, 1194, 1163, 
+	1163, 1163, 1194, 1194, 1163, 1194, 1194, 1194, 
+	1163, 1194, 1194, 1194, 1194, 1163, 1194, 1194, 
+	1194, 1163, 1194, 1194, 1163, 1267, 1268, 1253, 
+	1163, 1194, 1163, 1194, 1194, 1163, 1269, 1270, 
+	1271, 1272, 1273, 1274, 1275, 1163, 1276, 1277, 
+	1278, 1279, 1280, 1163, 1194, 1163, 1194, 1163, 
+	1194, 1163, 1194, 1194, 1194, 1194, 1194, 1163, 
+	1194, 1163, 1281, 1282, 1283, 1284, 1285, 1286, 
+	1287, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 
+	1295, 1296, 1297, 1294, 1298, 1299, 1300, 1301, 
+	1302, 1163, 1194, 1194, 1163, 1163, 1194, 1163, 
+	1163, 1194, 1194, 1194, 1163, 1194, 1163, 1194, 
+	1194, 1163, 1163, 1163, 1194, 1194, 1194, 1163, 
+	1194, 1163, 1194, 1194, 1194, 1163, 1194, 1194, 
+	1194, 1194, 1194, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1163, 1194, 1163, 1163, 1194, 1194, 1194, 
+	1163, 1163, 1163, 1194, 1163, 1194, 1194, 1163, 
+	1194, 1163, 1194, 1194, 1163, 1194, 1194, 1163, 
+	1303, 1304, 1305, 1306, 1163, 1194, 1163, 1194, 
+	1163, 1194, 1163, 1194, 1163, 1307, 1163, 1194, 
+	1163, 1308, 1309, 1310, 1311, 1312, 1313, 1163, 
+	1194, 1194, 1194, 1163, 1163, 1163, 1163, 1194, 
+	1194, 1163, 1194, 1194, 1163, 1163, 1163, 1194, 
+	1194, 1194, 1194, 1163, 1314, 1315, 1316, 1163, 
+	1194, 1194, 1194, 1194, 1194, 1163, 1194, 1163, 
+	1194, 1163, 1317, 1318, 1319, 1163, 1162, 1163, 
+	1194, 1163, 1194, 1163, 1320, 1163, 1321, 1322, 
+	1323, 1325, 1324, 1163, 1194, 1163, 1163, 1194, 
+	1194, 1269, 1270, 1271, 1272, 1273, 1274, 1163, 
+	1162, 1163, 1162, 1162, 1163, 1162, 1163, 1194, 
+	1162, 1162, 1162, 1194, 1194, 1163, 1162, 1162, 
+	1162, 1163, 1163, 1163, 1162, 1163, 1194, 1194, 
+	1162, 1162, 1194, 1163, 1162, 1162, 1162, 1163, 
+	1162, 1163, 1162, 1163, 1162, 1163, 1194, 1163, 
+	1163, 1162, 1162, 1163, 1162, 1163, 1194, 1162, 
+	1162, 1194, 1162, 1163, 1194, 1162, 1162, 1194, 
+	1194, 1162, 1162, 1163, 1162, 1162, 1194, 1163, 
+	1162, 1162, 1162, 1194, 1194, 1194, 1163, 1162, 
+	1194, 1162, 1163, 1163, 1163, 1194, 1163, 1163, 
+	1163, 1162, 1162, 1162, 1194, 1162, 1194, 1163, 
+	1162, 1162, 1194, 1194, 1194, 1162, 1162, 1162, 
+	1163, 1162, 1162, 1194, 1194, 1163, 1163, 1163, 
+	1162, 1162, 1162, 1163, 1162, 1163, 1194, 1162, 
+	1162, 1162, 1162, 1194, 1162, 1194, 1194, 1163, 
+	1162, 1194, 1162, 1163, 1162, 1163, 1162, 1194, 
+	1162, 1162, 1163, 1162, 1163, 1162, 1162, 1162, 
+	1162, 1194, 1163, 1194, 1162, 1163, 1162, 1162, 
+	1162, 1162, 1163, 1162, 1163, 1326, 1327, 1328, 
+	1329, 1330, 1331, 1332, 1333, 1334, 1335, 1336, 
+	1337, 1338, 1339, 1340, 1341, 1342, 1343, 1344, 
+	1345, 1346, 1163, 1194, 1162, 1162, 1194, 1162, 
+	1163, 1194, 1162, 1162, 1162, 1163, 1162, 1194, 
+	1162, 1162, 1162, 1163, 1162, 1163, 1162, 1162, 
+	1163, 1162, 1162, 1163, 1194, 1162, 1194, 1163, 
+	1162, 1162, 1162, 1163, 1194, 1162, 1163, 1162, 
+	1162, 1163, 1162, 1162, 1194, 1162, 1194, 1194, 
+	1162, 1163, 1162, 1162, 1194, 1163, 1162, 1162, 
+	1162, 1162, 1194, 1162, 1162, 1194, 1162, 1163, 
+	1162, 1163, 1194, 1194, 1194, 1162, 1162, 1194, 
+	1163, 1162, 1163, 1162, 1163, 1194, 1194, 1194, 
+	1194, 1162, 1162, 1194, 1162, 1163, 1194, 1162, 
+	1162, 1194, 1162, 1194, 1163, 1194, 1162, 1194, 
+	1162, 1163, 1194, 1162, 1162, 1162, 1162, 1194, 
+	1162, 1163, 1162, 1162, 1163, 1347, 1348, 1349, 
+	1350, 1351, 1163, 1162, 1248, 1163, 1162, 1163, 
+	1162, 1163, 1162, 1163, 1162, 1163, 1352, 1353, 
+	1163, 1162, 1163, 1162, 1163, 1354, 1355, 1356, 
+	1357, 1256, 1358, 1359, 1360, 1361, 1362, 1363, 
+	1364, 1365, 1366, 1367, 1163, 1162, 1162, 1163, 
+	1162, 1163, 1162, 1163, 1162, 1162, 1162, 1194, 
+	1194, 1162, 1163, 1162, 1163, 1162, 1163, 1194, 
+	1162, 1163, 1162, 1194, 1163, 1194, 1162, 1162, 
+	1162, 1194, 1162, 1194, 1163, 1162, 1163, 1194, 
+	1162, 1194, 1162, 1194, 1162, 1163, 1162, 1162, 
+	1194, 1162, 1163, 1162, 1162, 1162, 1162, 1163, 
+	1162, 1194, 1194, 1162, 1162, 1194, 1163, 1162, 
+	1162, 1194, 1162, 1194, 1163, 1368, 1369, 1355, 
+	1163, 1162, 1163, 1162, 1162, 1163, 1370, 1371, 
+	1372, 1373, 1374, 1375, 1376, 1163, 1377, 1378, 
+	1379, 1380, 1381, 1163, 1162, 1163, 1162, 1163, 
+	1162, 1163, 1162, 1162, 1162, 1162, 1162, 1163, 
+	1162, 1163, 1382, 1383, 1384, 1385, 1386, 1387, 
+	1388, 1389, 1390, 1391, 1392, 1393, 1394, 1395, 
+	1396, 1397, 1398, 1399, 1400, 1401, 1402, 1403, 
+	1404, 1163, 1162, 1194, 1162, 1163, 1163, 1162, 
+	1194, 1163, 1194, 1194, 1163, 1162, 1194, 1162, 
+	1162, 1163, 1162, 1163, 1194, 1162, 1194, 1162, 
+	1194, 1163, 1163, 1162, 1163, 1194, 1162, 1162, 
+	1194, 1162, 1194, 1162, 1163, 1162, 1194, 1162, 
+	1163, 1162, 1162, 1194, 1162, 1194, 1163, 1162, 
+	1162, 1194, 1194, 1194, 1194, 1162, 1162, 1163, 
+	1194, 1162, 1163, 1194, 1194, 1162, 1163, 1162, 
+	1194, 1162, 1194, 1162, 1194, 1162, 1163, 1194, 
+	1163, 1162, 1162, 1194, 1194, 1162, 1194, 1162, 
+	1163, 1163, 1163, 1162, 1162, 1194, 1162, 1194, 
+	1162, 1163, 1163, 1162, 1194, 1194, 1162, 1194, 
+	1162, 1163, 1194, 1162, 1194, 1162, 1163, 1194, 
+	1194, 1162, 1162, 1163, 1194, 1194, 1194, 1162, 
+	1162, 1163, 1405, 1406, 1305, 1407, 1163, 1162, 
+	1163, 1162, 1163, 1162, 1163, 1408, 1163, 1162, 
+	1163, 1409, 1410, 1411, 1412, 1413, 1414, 1163, 
+	1194, 1194, 1162, 1162, 1162, 1163, 1163, 1163, 
+	1163, 1162, 1162, 1163, 1162, 1162, 1163, 1163, 
+	1163, 1162, 1162, 1162, 1162, 1163, 1415, 1416, 
+	1417, 1163, 1162, 1162, 1162, 1162, 1162, 1163, 
+	1162, 1163, 1162, 1163, 1418, 1163, 1194, 1163, 
+	1419, 1163, 1420, 1421, 1422, 1424, 1423, 1163, 
+	1162, 1163, 1163, 1162, 1162, 1162, 3, 1, 
+	3, 1162, 3, 1, 601, 1, 1425, 1427, 
+	1428, 1429, 1430, 1431, 1432, 1427, 1428, 1429, 
+	1430, 1431, 1432, 1427, 601, 1426, 890, 1, 
+	3, 610, 3, 1, 875, 875, 875, 877, 
+	1, 875, 875, 877, 875, 875, 877, 875, 
+	875, 875, 877, 875, 875, 877, 875, 875, 
+	877, 875, 875, 1, 877, 1429, 1430, 1431, 
+	1432, 1426, 1427, 1429, 1430, 1431, 1432, 1426, 
+	1427, 1429, 1430, 1431, 1432, 1426, 1427, 1429, 
+	1430, 1431, 1432, 1426, 1427, 1429, 1430, 1431, 
+	1432, 1426, 1427, 1429, 1430, 1431, 1432, 1426, 
+	1427, 1429, 1430, 1431, 1432, 1426, 1427, 1429, 
+	1430, 1431, 1432, 1426, 1427, 1429, 1430, 1431, 
+	1432, 1426, 1427, 1428, 890, 1430, 1431, 1432, 
+	1426, 1427, 1428, 1430, 1431, 1432, 1426, 1427, 
+	1428, 1430, 1431, 1432, 1426, 1427, 1428, 1430, 
+	1431, 1432, 1426, 1427, 1428, 1430, 1431, 1432, 
+	1426, 1427, 1428, 1430, 1431, 1432, 1426, 1427, 
+	1428, 1430, 1431, 1432, 1426, 1427, 1428, 1430, 
+	1431, 1432, 1426, 1427, 1428, 1430, 1431, 1432, 
+	1426, 1427, 1428, 1429, 890, 1431, 1432, 1426, 
+	1427, 1428, 1429, 1431, 1432, 1426, 1427, 1428, 
+	1429, 1431, 1432, 1426, 1427, 1428, 1429, 1431, 
+	1432, 1426, 1427, 1428, 1429, 1431, 1433, 1434, 
+	1435, 1437, 1430, 1436, 1, 890, 875, 3, 
+	875, 877, 3, 877, 3, 1, 875, 1, 
+	265, 265, 1, 265, 1438, 1439, 601, 1, 
+	265, 3, 1, 3, 3, 265, 3, 1, 
+	1441, 1442, 1443, 1444, 1440, 1, 1445, 1446, 
+	601, 1, 266, 3, 1, 3, 266, 3, 
+	1, 1447, 601, 1, 3, 265, 3, 1, 
+	1448, 601, 1, 3, 265, 3, 1, 1449, 
+	1450, 1451, 1452, 1453, 1454, 1455, 1456, 1457, 
+	1458, 1459, 601, 1, 3, 1460, 1, 1462, 
+	1461, 1461, 1462, 1462, 1461, 1462, 1462, 1461, 
+	1462, 1462, 1462, 1461, 1462, 1461, 1462, 1462, 
+	1461, 1462, 1462, 1462, 1462, 1461, 1462, 1462, 
+	1461, 1461, 1462, 1462, 1461, 1462, 1461, 1463, 
+	1464, 1465, 1466, 1467, 1469, 1470, 1471, 1473, 
+	1474, 1475, 1476, 1477, 1478, 1479, 1480, 1481, 
+	1482, 1483, 1484, 1485, 1486, 1487, 1488, 1489, 
+	1490, 1468, 1472, 1461, 1462, 1462, 1462, 1462, 
+	1461, 1462, 1461, 1462, 1462, 1461, 1461, 1461, 
+	1462, 1461, 1461, 1461, 1462, 1462, 1462, 1462, 
+	1461, 1461, 1461, 1461, 1461, 1461, 1462, 1461, 
+	1461, 1461, 1461, 1461, 1461, 1462, 1461, 1461, 
+	1461, 1461, 1462, 1462, 1462, 1462, 1461, 1462, 
+	1462, 1462, 1462, 1462, 1461, 1462, 1462, 1461, 
+	1462, 1462, 1462, 1462, 1461, 1462, 1462, 1461, 
+	1461, 1461, 1461, 1461, 1461, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1461, 1462, 1462, 1461, 1461, 
+	1461, 1461, 1461, 1461, 1462, 1462, 1461, 1462, 
+	1462, 1462, 1462, 1462, 1461, 1462, 1462, 1461, 
+	1462, 1461, 1462, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1462, 1462, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1462, 1462, 1462, 1461, 1462, 1461, 1491, 
+	1492, 1493, 1494, 1495, 1496, 1497, 1498, 1499, 
+	1500, 1501, 1502, 1503, 1504, 1505, 1506, 1507, 
+	1508, 1509, 1510, 1511, 1461, 1462, 1462, 1461, 
+	1462, 1462, 1462, 1461, 1462, 1462, 1462, 1462, 
+	1461, 1462, 1461, 1462, 1462, 1461, 1462, 1462, 
+	1461, 1462, 1461, 1461, 1461, 1462, 1462, 1461, 
+	1462, 1462, 1461, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1462, 1462, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1462, 1461, 1461, 1461, 1462, 1462, 1462, 
+	1461, 1462, 1461, 1462, 1461, 1462, 1462, 1462, 
+	1462, 1462, 1461, 1462, 1462, 1461, 1512, 1513, 
+	1514, 1515, 1516, 1461, 1462, 1517, 1461, 1512, 
+	1513, 1518, 1514, 1515, 1516, 1461, 1462, 1461, 
+	1462, 1461, 1462, 1461, 1462, 1461, 1462, 1461, 
+	1519, 1520, 1461, 1462, 1461, 1462, 1461, 1521, 
+	1522, 1523, 1524, 1525, 1526, 1527, 1528, 1529, 
+	1530, 1531, 1532, 1533, 1534, 1535, 1461, 1462, 
+	1462, 1461, 1462, 1461, 1462, 1461, 1462, 1462, 
+	1462, 1462, 1461, 1462, 1462, 1461, 1461, 1461, 
+	1462, 1462, 1461, 1462, 1461, 1462, 1462, 1461, 
+	1461, 1461, 1462, 1462, 1461, 1462, 1462, 1462, 
+	1461, 1462, 1462, 1462, 1462, 1461, 1462, 1462, 
+	1462, 1461, 1462, 1462, 1461, 1536, 1537, 1522, 
+	1461, 1462, 1461, 1462, 1462, 1461, 1538, 1539, 
+	1540, 1541, 1542, 1543, 1544, 1461, 1545, 1546, 
+	1547, 1548, 1549, 1461, 1462, 1461, 1462, 1461, 
+	1462, 1461, 1462, 1462, 1462, 1462, 1462, 1461, 
+	1462, 1461, 1550, 1551, 1552, 1553, 1554, 1555, 
+	1556, 1557, 1558, 1559, 1560, 1561, 1562, 1563, 
+	1564, 1565, 1566, 1563, 1567, 1568, 1569, 1570, 
+	1571, 1461, 1462, 1462, 1461, 1461, 1462, 1461, 
+	1461, 1462, 1462, 1462, 1461, 1462, 1461, 1462, 
+	1462, 1461, 1461, 1461, 1462, 1462, 1462, 1461, 
+	1462, 1461, 1462, 1462, 1462, 1461, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1461, 1462, 1461, 1461, 1462, 1462, 1462, 
+	1461, 1461, 1461, 1462, 1461, 1462, 1462, 1461, 
+	1462, 1461, 1462, 1462, 1461, 1462, 1462, 1461, 
+	1572, 1573, 1574, 1575, 1461, 1462, 1461, 1462, 
+	1461, 1462, 1461, 1462, 1461, 1576, 1461, 1462, 
+	1461, 1577, 1578, 1579, 1580, 1581, 1582, 1461, 
+	1462, 1462, 1462, 1461, 1461, 1461, 1461, 1462, 
+	1462, 1461, 1462, 1462, 1461, 1461, 1461, 1462, 
+	1462, 1462, 1462, 1461, 1583, 1584, 1585, 1461, 
+	1462, 1462, 1462, 1462, 1462, 1461, 1462, 1461, 
+	1462, 1461, 1586, 1587, 1588, 1461, 1589, 1461, 
+	1589, 1461, 1461, 1589, 1589, 1461, 1589, 1589, 
+	1461, 1589, 1589, 1589, 1461, 1589, 1461, 1589, 
+	1589, 1461, 1589, 1589, 1589, 1589, 1461, 1589, 
+	1589, 1461, 1461, 1589, 1589, 1461, 1589, 1461, 
+	1590, 1591, 1592, 1593, 1594, 1595, 1596, 1598, 
+	1599, 1600, 1601, 1602, 1603, 1604, 1605, 1606, 
+	1607, 1608, 1609, 1481, 1610, 1611, 1612, 1613, 
+	1614, 1615, 1616, 1617, 1618, 1597, 1461, 1589, 
+	1589, 1589, 1589, 1461, 1589, 1461, 1589, 1589, 
+	1461, 1462, 1462, 1461, 1461, 1462, 1589, 1589, 
+	1461, 1589, 1589, 1461, 1589, 1461, 1462, 1589, 
+	1589, 1589, 1462, 1462, 1461, 1589, 1589, 1589, 
+	1461, 1461, 1461, 1589, 1461, 1462, 1462, 1589, 
+	1589, 1462, 1461, 1589, 1589, 1589, 1461, 1589, 
+	1461, 1589, 1461, 1589, 1461, 1462, 1461, 1461, 
+	1589, 1589, 1461, 1589, 1461, 1462, 1589, 1589, 
+	1462, 1589, 1461, 1462, 1589, 1589, 1462, 1462, 
+	1589, 1589, 1461, 1589, 1589, 1462, 1461, 1589, 
+	1589, 1589, 1462, 1462, 1462, 1461, 1589, 1462, 
+	1589, 1461, 1461, 1461, 1462, 1461, 1461, 1461, 
+	1589, 1589, 1589, 1462, 1589, 1462, 1461, 1589, 
+	1589, 1462, 1462, 1462, 1589, 1589, 1589, 1461, 
+	1589, 1589, 1462, 1462, 1461, 1461, 1461, 1589, 
+	1589, 1589, 1461, 1589, 1461, 1462, 1589, 1589, 
+	1589, 1589, 1462, 1589, 1462, 1462, 1461, 1589, 
+	1462, 1589, 1461, 1589, 1461, 1589, 1462, 1589, 
+	1589, 1461, 1589, 1461, 1589, 1589, 1589, 1589, 
+	1462, 1461, 1462, 1589, 1461, 1589, 1589, 1589, 
+	1589, 1461, 1589, 1461, 1619, 1620, 1621, 1622, 
+	1623, 1624, 1625, 1626, 1627, 1628, 1629, 1630, 
+	1631, 1632, 1633, 1634, 1635, 1636, 1637, 1638, 
+	1639, 1461, 1462, 1589, 1589, 1462, 1589, 1461, 
+	1462, 1589, 1589, 1589, 1461, 1589, 1462, 1589, 
+	1589, 1589, 1461, 1589, 1461, 1589, 1589, 1461, 
+	1589, 1589, 1461, 1462, 1589, 1462, 1461, 1589, 
+	1589, 1589, 1461, 1462, 1589, 1461, 1589, 1589, 
+	1461, 1589, 1589, 1462, 1589, 1462, 1462, 1589, 
+	1461, 1589, 1589, 1462, 1461, 1589, 1589, 1589, 
+	1589, 1462, 1589, 1589, 1462, 1589, 1461, 1589, 
+	1461, 1462, 1462, 1462, 1589, 1589, 1462, 1461, 
+	1589, 1461, 1589, 1461, 1462, 1462, 1462, 1462, 
+	1589, 1589, 1462, 1589, 1461, 1462, 1589, 1589, 
+	1462, 1589, 1462, 1461, 1462, 1589, 1462, 1589, 
+	1461, 1462, 1589, 1589, 1589, 1589, 1462, 1589, 
+	1461, 1589, 1589, 1461, 1640, 1641, 1642, 1643, 
+	1644, 1461, 1589, 1517, 1461, 1589, 1461, 1589, 
+	1461, 1589, 1461, 1589, 1461, 1645, 1646, 1461, 
+	1589, 1461, 1589, 1461, 1647, 1648, 1649, 1650, 
+	1525, 1651, 1652, 1653, 1654, 1655, 1656, 1657, 
+	1658, 1659, 1660, 1461, 1589, 1589, 1461, 1589, 
+	1461, 1589, 1461, 1589, 1589, 1589, 1462, 1462, 
+	1589, 1461, 1589, 1461, 1589, 1461, 1462, 1589, 
+	1461, 1589, 1462, 1461, 1462, 1589, 1589, 1589, 
+	1462, 1589, 1462, 1461, 1589, 1461, 1462, 1589, 
+	1462, 1589, 1462, 1589, 1461, 1589, 1589, 1462, 
+	1589, 1461, 1589, 1589, 1589, 1589, 1461, 1589, 
+	1462, 1462, 1589, 1589, 1462, 1461, 1589, 1589, 
+	1462, 1589, 1462, 1461, 1661, 1662, 1648, 1461, 
+	1589, 1461, 1589, 1589, 1461, 1663, 1664, 1665, 
+	1666, 1667, 1668, 1669, 1461, 1670, 1671, 1672, 
+	1673, 1674, 1461, 1589, 1461, 1589, 1461, 1589, 
+	1461, 1589, 1589, 1589, 1589, 1589, 1461, 1589, 
+	1461, 1675, 1676, 1677, 1678, 1679, 1680, 1681, 
+	1682, 1683, 1684, 1685, 1686, 1687, 1688, 1689, 
+	1690, 1691, 1692, 1693, 1694, 1695, 1696, 1697, 
+	1461, 1589, 1462, 1589, 1461, 1461, 1589, 1462, 
+	1461, 1462, 1462, 1461, 1589, 1462, 1589, 1589, 
+	1461, 1589, 1461, 1462, 1589, 1462, 1589, 1462, 
+	1461, 1461, 1589, 1461, 1462, 1589, 1589, 1462, 
+	1589, 1462, 1589, 1461, 1589, 1462, 1589, 1461, 
+	1589, 1589, 1462, 1589, 1462, 1461, 1589, 1589, 
+	1462, 1462, 1462, 1462, 1589, 1589, 1461, 1462, 
+	1589, 1461, 1462, 1462, 1589, 1461, 1589, 1462, 
+	1589, 1462, 1589, 1462, 1589, 1461, 1462, 1461, 
+	1589, 1589, 1462, 1462, 1589, 1462, 1589, 1461, 
+	1461, 1461, 1589, 1589, 1462, 1589, 1462, 1589, 
+	1461, 1461, 1589, 1462, 1462, 1589, 1462, 1589, 
+	1461, 1462, 1589, 1462, 1589, 1461, 1462, 1462, 
+	1589, 1589, 1461, 1462, 1462, 1462, 1589, 1589, 
+	1461, 1698, 1699, 1574, 1700, 1461, 1589, 1461, 
+	1589, 1461, 1589, 1461, 1701, 1461, 1589, 1461, 
+	1702, 1703, 1704, 1705, 1706, 1707, 1461, 1462, 
+	1462, 1589, 1589, 1589, 1461, 1461, 1461, 1461, 
+	1589, 1589, 1461, 1589, 1589, 1461, 1461, 1461, 
+	1589, 1589, 1589, 1589, 1461, 1708, 1709, 1710, 
+	1461, 1589, 1589, 1589, 1589, 1589, 1461, 1589, 
+	1461, 1589, 1461, 1711, 1461, 1462, 1461, 1712, 
+	1461, 1713, 1714, 1715, 1717, 1716, 1461, 1589, 
+	1461, 1461, 1589, 1589, 1462, 1461, 1462, 1461, 
+	1718, 1461, 1719, 1720, 1721, 1723, 1722, 1461, 
+	1462, 1461, 1461, 1462, 1462, 1538, 1539, 1540, 
+	1541, 1542, 1543, 1461, 1538, 1539, 1540, 1541, 
+	1542, 1543, 1724, 1461, 1725, 1461, 1462, 1461, 
+	1162, 3, 1, 3, 1162, 3, 1162, 3, 
+	1, 1162, 1162, 3, 1162, 3, 1162, 3, 
+	1162, 3, 1162, 3, 1, 3, 3, 1162, 
+	1162, 3, 1, 1162, 1162, 3, 1, 1162, 
+	3, 1162, 3, 1, 3, 1162, 3, 1162, 
+	3, 1, 1162, 3, 1162, 3, 1, 1162, 
+	3, 1, 1162, 1162, 3, 3, 1162, 3, 
+	1162, 3, 1162, 1, 1440, 1, 1726, 1440, 
+	1, 1727, 1435, 1437, 1728, 1437, 601, 1436, 
+	1, 265, 3, 1, 3, 265, 1, 1, 
+	1730, 1729, 1733, 1734, 1735, 1736, 1737, 1738, 
+	1739, 1741, 1742, 1743, 1744, 1745, 1746, 1748, 
+	1729, 1, 1732, 1740, 1747, 1, 1731, 262, 
+	264, 1750, 1751, 1752, 1753, 1754, 1755, 1756, 
+	1757, 1758, 1759, 1760, 1761, 1762, 1763, 1764, 
+	1765, 1766, 1767, 1749, 262, 264, 1750, 1751, 
+	1752, 1753, 1754, 1755, 1756, 1757, 1758, 1759, 
+	1760, 1761, 1768, 1763, 1764, 1765, 1769, 1767, 
+	1749, 256, 258, 1770, 1771, 1772, 1773, 1774, 
+	1775, 1776, 1777, 1778, 1779, 1780, 1781, 1782, 
+	1783, 1784, 1785, 1786, 1787, 1749, 1789, 1790, 
+	1791, 1792, 1793, 1794, 1795, 1796, 1797, 1798, 
+	1799, 1800, 1801, 1803, 268, 530, 576, 1802, 
+	1788, 527, 529, 1804, 1805, 1806, 1807, 1808, 
+	1809, 1810, 1811, 1812, 1813, 1814, 1815, 1816, 
+	1817, 1818, 1819, 1820, 1821, 1788, 527, 529, 
+	1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 
+	1812, 1813, 1814, 1815, 1822, 1817, 1818, 1819, 
+	1823, 1821, 1788, 521, 523, 1824, 1825, 1826, 
+	1827, 1828, 1829, 1830, 1831, 1832, 1833, 1834, 
+	1835, 1836, 1837, 1838, 1839, 1840, 1841, 1788, 
+	527, 529, 1804, 1805, 1806, 1807, 1808, 1809, 
+	1810, 1811, 1812, 1813, 1814, 1842, 1816, 1817, 
+	1843, 1844, 1845, 1846, 1819, 1820, 1821, 1788, 
+	527, 529, 1804, 1805, 1806, 1807, 1808, 1809, 
+	1810, 1811, 1812, 1813, 1814, 1847, 1816, 1817, 
+	1818, 1848, 1819, 1820, 1821, 1788, 527, 529, 
+	1804, 1805, 1806, 1807, 1808, 1809, 1810, 1811, 
+	1812, 1813, 1814, 1849, 1816, 1817, 1818, 1850, 
+	1819, 1820, 1821, 1788, 527, 529, 1804, 1805, 
+	1806, 1807, 1808, 1809, 1810, 1811, 1812, 1813, 
+	1814, 1851, 1816, 1817, 1818, 1852, 1819, 1820, 
+	1821, 1788, 527, 529, 1804, 1805, 1806, 1807, 
+	1808, 1809, 1810, 1811, 1812, 1813, 1814, 1815, 
+	1816, 1817, 1818, 1819, 1853, 1821, 1788, 871, 
+	873, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 
+	1862, 1863, 1864, 1865, 1866, 1867, 1868, 1869, 
+	1870, 1871, 1872, 1873, 1874, 1875, 1854, 871, 
+	873, 1855, 1856, 1857, 1858, 1859, 1860, 1861, 
+	1862, 1863, 1864, 1865, 1876, 1867, 1868, 1877, 
+	1873, 1874, 1875, 1854, 871, 873, 1855, 1856, 
+	1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 
+	1865, 1876, 1878, 1868, 1877, 1873, 1879, 1875, 
+	1854, 865, 867, 1880, 1881, 1882, 1883, 1884, 
+	1885, 1886, 1887, 1888, 1889, 1890, 1891, 1892, 
+	1893, 1894, 1895, 1896, 1897, 1854, 871, 873, 
+	1855, 1856, 1857, 1858, 1859, 1860, 1861, 1862, 
+	1863, 1864, 1865, 1898, 1867, 1868, 1877, 1899, 
+	1873, 1874, 1875, 1854, 871, 873, 1855, 1856, 
+	1857, 1858, 1859, 1860, 1861, 1862, 1863, 1864, 
+	1865, 1900, 1867, 1868, 1877, 1901, 1873, 1874, 
+	1875, 1854, 871, 873, 1855, 1856, 1857, 1858, 
+	1859, 1860, 1861, 1862, 1863, 1864, 1865, 1902, 
+	1867, 1868, 1877, 1903, 1873, 1874, 1875, 1854, 
+	1025, 1027, 1905, 1906, 1907, 1908, 1909, 1910, 
+	1911, 1912, 1913, 1914, 1915, 1916, 1917, 1918, 
+	1919, 1920, 1921, 1922, 1904, 1025, 1027, 1905, 
+	1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 
+	1914, 1915, 1916, 1923, 1918, 1919, 1920, 1924, 
+	1922, 1904, 1159, 1161, 1925, 1926, 1927, 1928, 
+	1929, 1930, 1931, 1932, 1933, 1934, 1935, 1936, 
+	1937, 1938, 1939, 1940, 1941, 1942, 1904, 1422, 
+	1424, 1944, 1945, 1946, 1947, 1948, 1949, 1950, 
+	1951, 1952, 1953, 1954, 1955, 1956, 1957, 1958, 
+	1959, 1960, 1961, 1943, 1323, 1325, 1962, 1963, 
+	1964, 1965, 1966, 1967, 1968, 1969, 1970, 1971, 
+	1972, 1973, 1974, 1975, 1976, 1977, 1978, 1979, 
+	1943, 1323, 1325, 1962, 1963, 1964, 1965, 1966, 
+	1967, 1968, 1969, 1970, 1971, 1972, 1973, 1980, 
+	1975, 1976, 1977, 1981, 1979, 1943, 1721, 1723, 
+	1983, 1984, 1985, 1986, 1987, 1988, 1989, 1990, 
+	1991, 1992, 1993, 1994, 1995, 1996, 1997, 1998, 
+	1999, 2000, 1982, 1721, 1723, 1983, 1984, 1985, 
+	1986, 1987, 1988, 1989, 1990, 1991, 1992, 1993, 
+	1994, 1995, 1996, 1997, 1998, 2001, 2000, 1982, 
+	1721, 1723, 1983, 1984, 1985, 1986, 1987, 1988, 
+	1989, 1990, 1991, 1992, 1993, 1994, 2002, 1996, 
+	1997, 1998, 2003, 2000, 1982, 1715, 1717, 2004, 
+	2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012, 
+	2013, 2014, 2015, 2016, 2017, 2018, 2019, 2020, 
+	2021, 1982, 
+}
+
+var _graphclust_trans_targs []int16 = []int16{
+	1974, 0, 1974, 1975, 15, 16, 17, 18, 
+	19, 20, 21, 22, 23, 24, 25, 26, 
+	27, 28, 29, 30, 31, 32, 33, 34, 
+	35, 36, 37, 38, 39, 40, 41, 42, 
+	44, 45, 46, 47, 48, 49, 50, 51, 
+	52, 53, 54, 55, 56, 57, 58, 59, 
+	60, 61, 62, 63, 64, 66, 68, 70, 
+	71, 72, 1976, 69, 74, 75, 77, 78, 
+	79, 80, 81, 82, 83, 84, 85, 86, 
+	87, 88, 89, 90, 91, 93, 94, 96, 
+	102, 125, 130, 132, 139, 143, 97, 98, 
+	99, 100, 101, 103, 104, 105, 106, 107, 
+	108, 109, 110, 111, 112, 113, 114, 115, 
+	116, 117, 118, 119, 120, 121, 122, 123, 
+	124, 126, 127, 128, 129, 131, 133, 134, 
+	135, 136, 137, 138, 140, 141, 142, 144, 
+	291, 292, 1977, 158, 159, 160, 161, 162, 
+	163, 164, 165, 166, 167, 168, 169, 170, 
+	171, 172, 173, 174, 175, 176, 177, 178, 
+	179, 180, 181, 182, 183, 184, 185, 186, 
+	188, 189, 190, 191, 192, 193, 194, 195, 
+	196, 197, 198, 199, 200, 201, 202, 203, 
+	204, 205, 206, 207, 208, 210, 211, 212, 
+	213, 214, 216, 217, 219, 220, 221, 222, 
+	223, 224, 225, 226, 227, 228, 229, 230, 
+	231, 232, 234, 235, 237, 243, 267, 271, 
+	273, 280, 284, 238, 239, 240, 241, 242, 
+	244, 245, 246, 247, 248, 249, 250, 251, 
+	252, 253, 254, 255, 256, 257, 258, 259, 
+	260, 261, 262, 263, 264, 265, 266, 268, 
+	269, 270, 272, 274, 275, 276, 277, 278, 
+	279, 281, 282, 283, 285, 287, 288, 289, 
+	145, 290, 146, 294, 295, 296, 2, 297, 
+	3, 1974, 1978, 1974, 1979, 315, 316, 317, 
+	318, 319, 320, 321, 322, 323, 324, 325, 
+	326, 327, 328, 329, 330, 331, 332, 333, 
+	334, 335, 336, 337, 338, 339, 340, 341, 
+	342, 344, 345, 346, 347, 348, 349, 350, 
+	351, 352, 353, 354, 355, 356, 357, 358, 
+	359, 360, 361, 362, 363, 364, 366, 368, 
+	370, 371, 372, 1980, 369, 374, 375, 377, 
+	378, 379, 380, 381, 382, 383, 384, 385, 
+	386, 387, 388, 389, 390, 391, 393, 394, 
+	396, 402, 425, 430, 432, 439, 443, 397, 
+	398, 399, 400, 401, 403, 404, 405, 406, 
+	407, 408, 409, 410, 411, 412, 413, 414, 
+	415, 416, 417, 418, 419, 420, 421, 422, 
+	423, 424, 426, 427, 428, 429, 431, 433, 
+	434, 435, 436, 437, 438, 440, 441, 442, 
+	444, 591, 592, 1981, 458, 459, 460, 461, 
+	462, 463, 464, 465, 466, 467, 468, 469, 
+	470, 471, 472, 473, 474, 475, 476, 477, 
+	478, 479, 480, 481, 482, 483, 484, 485, 
+	486, 488, 489, 490, 491, 492, 493, 494, 
+	495, 496, 497, 498, 499, 500, 501, 502, 
+	503, 504, 505, 506, 507, 508, 510, 511, 
+	512, 513, 514, 516, 517, 519, 520, 521, 
+	522, 523, 524, 525, 526, 527, 528, 529, 
+	530, 531, 532, 534, 535, 537, 543, 567, 
+	571, 573, 580, 584, 538, 539, 540, 541, 
+	542, 544, 545, 546, 547, 548, 549, 550, 
+	551, 552, 553, 554, 555, 556, 557, 558, 
+	559, 560, 561, 562, 563, 564, 565, 566, 
+	568, 569, 570, 572, 574, 575, 576, 577, 
+	578, 579, 581, 582, 583, 585, 587, 588, 
+	589, 445, 590, 446, 594, 595, 596, 302, 
+	597, 303, 599, 605, 606, 608, 610, 613, 
+	616, 640, 1982, 622, 1983, 612, 1984, 615, 
+	618, 620, 621, 624, 625, 629, 630, 631, 
+	632, 633, 634, 635, 1985, 628, 639, 642, 
+	643, 644, 645, 646, 649, 650, 651, 652, 
+	653, 654, 655, 656, 660, 661, 663, 664, 
+	647, 666, 669, 671, 673, 667, 668, 670, 
+	672, 674, 678, 679, 680, 681, 682, 683, 
+	684, 685, 686, 687, 1986, 676, 677, 690, 
+	691, 299, 695, 696, 698, 997, 1000, 1003, 
+	1027, 1974, 1987, 1974, 1988, 712, 713, 714, 
+	715, 716, 717, 718, 719, 720, 721, 722, 
+	723, 724, 725, 726, 727, 728, 729, 730, 
+	731, 732, 733, 734, 735, 736, 737, 738, 
+	739, 741, 742, 743, 744, 745, 746, 747, 
+	748, 749, 750, 751, 752, 753, 754, 755, 
+	756, 757, 758, 759, 760, 761, 763, 765, 
+	767, 768, 769, 1989, 766, 771, 772, 774, 
+	775, 776, 777, 778, 779, 780, 781, 782, 
+	783, 784, 785, 786, 787, 788, 790, 791, 
+	793, 799, 822, 827, 829, 836, 840, 794, 
+	795, 796, 797, 798, 800, 801, 802, 803, 
+	804, 805, 806, 807, 808, 809, 810, 811, 
+	812, 813, 814, 815, 816, 817, 818, 819, 
+	820, 821, 823, 824, 825, 826, 828, 830, 
+	831, 832, 833, 834, 835, 837, 838, 839, 
+	841, 988, 989, 1990, 855, 856, 857, 858, 
+	859, 860, 861, 862, 863, 864, 865, 866, 
+	867, 868, 869, 870, 871, 872, 873, 874, 
+	875, 876, 877, 878, 879, 880, 881, 882, 
+	883, 885, 886, 887, 888, 889, 890, 891, 
+	892, 893, 894, 895, 896, 897, 898, 899, 
+	900, 901, 902, 903, 904, 905, 907, 908, 
+	909, 910, 911, 913, 914, 916, 917, 918, 
+	919, 920, 921, 922, 923, 924, 925, 926, 
+	927, 928, 929, 931, 932, 934, 940, 964, 
+	968, 970, 977, 981, 935, 936, 937, 938, 
+	939, 941, 942, 943, 944, 945, 946, 947, 
+	948, 949, 950, 951, 952, 953, 954, 955, 
+	956, 957, 958, 959, 960, 961, 962, 963, 
+	965, 966, 967, 969, 971, 972, 973, 974, 
+	975, 976, 978, 979, 980, 982, 984, 985, 
+	986, 842, 987, 843, 991, 992, 993, 699, 
+	994, 700, 1009, 1991, 999, 1992, 1002, 1005, 
+	1007, 1008, 1011, 1012, 1016, 1017, 1018, 1019, 
+	1020, 1021, 1022, 1993, 1015, 1026, 1029, 1327, 
+	1328, 1626, 1627, 1994, 1974, 1995, 1043, 1044, 
+	1045, 1046, 1047, 1048, 1049, 1050, 1051, 1052, 
+	1053, 1054, 1055, 1056, 1057, 1058, 1059, 1060, 
+	1061, 1062, 1063, 1064, 1065, 1066, 1067, 1068, 
+	1069, 1070, 1072, 1073, 1074, 1075, 1076, 1077, 
+	1078, 1079, 1080, 1081, 1082, 1083, 1084, 1085, 
+	1086, 1087, 1088, 1089, 1090, 1091, 1092, 1094, 
+	1095, 1096, 1097, 1098, 1100, 1101, 1103, 1104, 
+	1105, 1106, 1107, 1108, 1109, 1110, 1111, 1112, 
+	1113, 1114, 1115, 1116, 1117, 1119, 1120, 1122, 
+	1128, 1151, 1156, 1158, 1165, 1123, 1124, 1125, 
+	1126, 1127, 1129, 1130, 1131, 1132, 1133, 1134, 
+	1135, 1136, 1137, 1138, 1139, 1140, 1141, 1142, 
+	1143, 1144, 1145, 1146, 1147, 1148, 1149, 1150, 
+	1152, 1153, 1154, 1155, 1157, 1159, 1160, 1161, 
+	1162, 1163, 1164, 1166, 1167, 1168, 1170, 1171, 
+	1172, 1030, 1173, 1031, 1175, 1177, 1178, 1325, 
+	1326, 1996, 1192, 1193, 1194, 1195, 1196, 1197, 
+	1198, 1199, 1200, 1201, 1202, 1203, 1204, 1205, 
+	1206, 1207, 1208, 1209, 1210, 1211, 1212, 1213, 
+	1214, 1215, 1216, 1217, 1218, 1219, 1220, 1222, 
+	1223, 1224, 1225, 1226, 1227, 1228, 1229, 1230, 
+	1231, 1232, 1233, 1234, 1235, 1236, 1237, 1238, 
+	1239, 1240, 1241, 1242, 1244, 1245, 1246, 1247, 
+	1248, 1250, 1251, 1253, 1254, 1255, 1256, 1257, 
+	1258, 1259, 1260, 1261, 1262, 1263, 1264, 1265, 
+	1266, 1268, 1269, 1271, 1277, 1301, 1305, 1307, 
+	1314, 1318, 1272, 1273, 1274, 1275, 1276, 1278, 
+	1279, 1280, 1281, 1282, 1283, 1284, 1285, 1286, 
+	1287, 1288, 1289, 1290, 1291, 1292, 1293, 1294, 
+	1295, 1296, 1297, 1298, 1299, 1300, 1302, 1303, 
+	1304, 1306, 1308, 1309, 1310, 1311, 1312, 1313, 
+	1315, 1316, 1317, 1319, 1321, 1322, 1323, 1179, 
+	1324, 1180, 1997, 1974, 1342, 1343, 1344, 1345, 
+	1497, 1498, 1499, 1500, 1501, 1502, 1503, 1504, 
+	1505, 1506, 1507, 1508, 1509, 1510, 1511, 1512, 
+	1377, 1513, 1514, 1515, 1516, 1517, 1518, 1519, 
+	1520, 1521, 1998, 1359, 1360, 1361, 1362, 1363, 
+	1364, 1365, 1366, 1367, 1368, 1369, 1370, 1371, 
+	1372, 1373, 1374, 1375, 1376, 1378, 1379, 1380, 
+	1381, 1382, 1383, 1384, 1385, 1386, 1388, 1389, 
+	1390, 1391, 1392, 1393, 1394, 1395, 1396, 1397, 
+	1398, 1399, 1400, 1401, 1402, 1403, 1404, 1405, 
+	1406, 1407, 1408, 1410, 1412, 1414, 1415, 1416, 
+	1999, 1413, 1418, 1419, 1421, 1422, 1423, 1424, 
+	1425, 1426, 1427, 1428, 1429, 1430, 1431, 1432, 
+	1433, 1434, 1435, 1437, 1438, 1440, 1446, 1469, 
+	1474, 1476, 1483, 1487, 1441, 1442, 1443, 1444, 
+	1445, 1447, 1448, 1449, 1450, 1451, 1452, 1453, 
+	1454, 1455, 1456, 1457, 1458, 1459, 1460, 1461, 
+	1462, 1463, 1464, 1465, 1466, 1467, 1468, 1470, 
+	1471, 1472, 1473, 1475, 1477, 1478, 1479, 1480, 
+	1481, 1482, 1484, 1485, 1486, 1488, 1489, 1490, 
+	1492, 1493, 1494, 1346, 1495, 1347, 1523, 1524, 
+	1525, 1526, 1527, 1528, 1529, 1530, 1531, 1532, 
+	1533, 1534, 1535, 1536, 1537, 1538, 1539, 1540, 
+	1541, 1542, 1543, 1545, 1546, 1547, 1548, 1549, 
+	1551, 1552, 1554, 1555, 1556, 1557, 1558, 1559, 
+	1560, 1561, 1562, 1563, 1564, 1565, 1566, 1567, 
+	1569, 1570, 1572, 1578, 1602, 1606, 1608, 1615, 
+	1619, 1573, 1574, 1575, 1576, 1577, 1579, 1580, 
+	1581, 1582, 1583, 1584, 1585, 1586, 1587, 1588, 
+	1589, 1590, 1591, 1592, 1593, 1594, 1595, 1596, 
+	1597, 1598, 1599, 1600, 1601, 1603, 1604, 1605, 
+	1607, 1609, 1610, 1611, 1612, 1613, 1614, 1616, 
+	1617, 1618, 1620, 1622, 1623, 1624, 1329, 1625, 
+	1330, 1630, 1631, 1632, 1633, 1634, 1635, 1636, 
+	1637, 1641, 1642, 1643, 1644, 1645, 1647, 1648, 
+	1628, 1650, 1653, 1655, 1657, 1651, 1652, 1654, 
+	1656, 1658, 1959, 1960, 1961, 1962, 1963, 1964, 
+	1965, 1966, 1967, 1968, 2000, 1974, 2001, 1672, 
+	1673, 1674, 1675, 1676, 1677, 1678, 1679, 1680, 
+	1681, 1682, 1683, 1684, 1685, 1686, 1687, 1688, 
+	1689, 1690, 1691, 1692, 1693, 1694, 1695, 1696, 
+	1697, 1698, 1699, 1701, 1702, 1703, 1704, 1705, 
+	1706, 1707, 1708, 1709, 1710, 1711, 1712, 1713, 
+	1714, 1715, 1716, 1717, 1718, 1719, 1720, 1721, 
+	1723, 1725, 1727, 1728, 1729, 2002, 1726, 1731, 
+	1732, 1734, 1735, 1736, 1737, 1738, 1739, 1740, 
+	1741, 1742, 1743, 1744, 1745, 1746, 1747, 1748, 
+	1750, 1751, 1753, 1759, 1782, 1787, 1789, 1796, 
+	1800, 1754, 1755, 1756, 1757, 1758, 1760, 1761, 
+	1762, 1763, 1764, 1765, 1766, 1767, 1768, 1769, 
+	1770, 1771, 1772, 1773, 1774, 1775, 1776, 1777, 
+	1778, 1779, 1780, 1781, 1783, 1784, 1785, 1786, 
+	1788, 1790, 1791, 1792, 1793, 1794, 1795, 1797, 
+	1798, 1799, 1801, 1948, 1949, 2003, 1815, 1816, 
+	1817, 1818, 1819, 1820, 1821, 1822, 1823, 1824, 
+	1825, 1826, 1827, 1828, 1829, 1830, 1831, 1832, 
+	1833, 1834, 1835, 1836, 1837, 1838, 1839, 1840, 
+	1841, 1842, 1843, 1845, 1846, 1847, 1848, 1849, 
+	1850, 1851, 1852, 1853, 1854, 1855, 1856, 1857, 
+	1858, 1859, 1860, 1861, 1862, 1863, 1864, 1865, 
+	1867, 1868, 1869, 1870, 1871, 1873, 1874, 1876, 
+	1877, 1878, 1879, 1880, 1881, 1882, 1883, 1884, 
+	1885, 1886, 1887, 1888, 1889, 1891, 1892, 1894, 
+	1900, 1924, 1928, 1930, 1937, 1941, 1895, 1896, 
+	1897, 1898, 1899, 1901, 1902, 1903, 1904, 1905, 
+	1906, 1907, 1908, 1909, 1910, 1911, 1912, 1913, 
+	1914, 1915, 1916, 1917, 1918, 1919, 1920, 1921, 
+	1922, 1923, 1925, 1926, 1927, 1929, 1931, 1932, 
+	1933, 1934, 1935, 1936, 1938, 1939, 1940, 1942, 
+	1944, 1945, 1946, 1802, 1947, 1803, 1951, 1952, 
+	1953, 1659, 1954, 1660, 1957, 1958, 1971, 1972, 
+	1973, 1974, 1, 1975, 299, 300, 301, 692, 
+	693, 694, 697, 1028, 1628, 1629, 1638, 1639, 
+	1640, 1646, 1649, 1969, 1970, 1974, 4, 5, 
+	6, 7, 8, 9, 10, 11, 12, 13, 
+	14, 43, 65, 73, 76, 92, 298, 293, 
+	67, 95, 147, 148, 149, 150, 151, 152, 
+	153, 154, 155, 156, 157, 187, 209, 215, 
+	218, 233, 236, 286, 1974, 600, 601, 602, 
+	603, 604, 607, 641, 648, 657, 658, 659, 
+	662, 665, 688, 689, 304, 305, 306, 307, 
+	308, 309, 310, 311, 312, 313, 314, 343, 
+	365, 373, 376, 392, 598, 593, 367, 395, 
+	447, 448, 449, 450, 451, 452, 453, 454, 
+	455, 456, 457, 487, 509, 515, 518, 533, 
+	536, 586, 609, 623, 636, 637, 638, 611, 
+	619, 614, 617, 626, 627, 675, 1974, 701, 
+	702, 703, 704, 705, 706, 707, 708, 709, 
+	710, 711, 996, 762, 770, 1010, 1023, 1024, 
+	1025, 789, 995, 990, 740, 773, 764, 792, 
+	844, 845, 846, 847, 848, 849, 850, 851, 
+	852, 853, 854, 884, 906, 912, 915, 930, 
+	933, 983, 998, 1006, 1001, 1004, 1013, 1014, 
+	1974, 1032, 1033, 1034, 1035, 1036, 1037, 1038, 
+	1039, 1040, 1041, 1042, 1071, 1174, 1099, 1102, 
+	1118, 1176, 1169, 1093, 1121, 1181, 1182, 1183, 
+	1184, 1185, 1186, 1187, 1188, 1189, 1190, 1191, 
+	1221, 1243, 1249, 1252, 1267, 1270, 1320, 1974, 
+	1331, 1332, 1333, 1334, 1335, 1336, 1337, 1338, 
+	1339, 1340, 1341, 1522, 1544, 1550, 1553, 1568, 
+	1571, 1621, 1348, 1349, 1350, 1351, 1352, 1353, 
+	1354, 1355, 1356, 1357, 1358, 1387, 1409, 1417, 
+	1420, 1436, 1496, 1491, 1411, 1439, 1974, 1661, 
+	1662, 1663, 1664, 1665, 1666, 1667, 1668, 1669, 
+	1670, 1671, 1700, 1722, 1730, 1733, 1749, 1956, 
+	1950, 1955, 1724, 1752, 1804, 1805, 1806, 1807, 
+	1808, 1809, 1810, 1811, 1812, 1813, 1814, 1844, 
+	1866, 1872, 1875, 1890, 1893, 1943, 
+}
+
+var _graphclust_trans_actions []byte = []byte{
+	31, 0, 27, 40, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 40, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 40, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 34, 40, 25, 40, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 40, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 40, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 40, 0, 40, 0, 40, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 40, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 40, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 29, 51, 17, 40, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 40, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 40, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 51, 0, 51, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 40, 0, 0, 0, 0, 
+	0, 0, 0, 40, 21, 40, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 40, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 40, 19, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 40, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	40, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 40, 23, 40, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 40, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 40, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 43, 1, 47, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 1, 1, 1, 
+	1, 1, 1, 1, 1, 15, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 13, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 5, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	9, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 7, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 11, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 
+}
+
+var _graphclust_to_state_actions []byte = []byte{
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 37, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 
+}
+
+var _graphclust_from_state_actions []byte = []byte{
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 3, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 
+}
+
+var _graphclust_eof_trans []int16 = []int16{
+	0, 0, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 3, 3, 3, 3, 3, 
+	3, 3, 3, 0, 0, 0, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 268, 268, 268, 268, 
+	268, 268, 268, 268, 0, 0, 0, 0, 
+	0, 0, 610, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 610, 612, 612, 
+	610, 612, 612, 610, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 612, 612, 
+	612, 612, 612, 612, 612, 612, 610, 612, 
+	612, 612, 612, 0, 0, 0, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 901, 
+	901, 901, 901, 901, 901, 901, 901, 0, 
+	0, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 1164, 1164, 1164, 1164, 1164, 1164, 
+	1164, 1164, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 1462, 
+	1462, 1462, 1462, 1462, 1462, 1462, 1462, 0, 
+	0, 0, 0, 0, 0, 0, 0, 0, 
+	0, 0, 0, 0, 0, 0, 0, 1750, 
+	1750, 1750, 1789, 1789, 1789, 1789, 1789, 1789, 
+	1789, 1789, 1789, 1855, 1855, 1855, 1855, 1855, 
+	1855, 1855, 1905, 1905, 1905, 1944, 1944, 1944, 
+	1983, 1983, 1983, 1983, 
+}
+
+const graphclust_start int = 1974
+const graphclust_first_final int = 1974
+const graphclust_error int = 0
+
+const graphclust_en_main int = 1974
+
+
+// line 14 "grapheme_clusters.rl"
+
+
+var Error = errors.New("invalid UTF8 text")
+
+// ScanGraphemeClusters is a split function for bufio.Scanner that splits
+// on grapheme cluster boundaries.
+func ScanGraphemeClusters(data []byte, atEOF bool) (int, []byte, error) {
+    if len(data) == 0 {
+        return 0, nil, nil
+    }
+
+    // Ragel state
+	cs := 0 // Current State
+	p := 0  // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+    ts := 0
+    te := 0
+    act := 0
+    eof := pe
+
+    // Make Go compiler happy
+    _ = ts
+    _ = te
+    _ = act
+    _ = eof
+
+    startPos := 0
+    endPos := 0
+
+    
+// line 4976 "grapheme_clusters.go"
+	{
+	cs = graphclust_start
+	ts = 0
+	te = 0
+	act = 0
+	}
+
+// line 4984 "grapheme_clusters.go"
+	{
+	var _klen int
+	var _trans int
+	var _acts int
+	var _nacts uint
+	var _keys int
+	if p == pe {
+		goto _test_eof
+	}
+	if cs == 0 {
+		goto _out
+	}
+_resume:
+	_acts = int(_graphclust_from_state_actions[cs])
+	_nacts = uint(_graphclust_actions[_acts]); _acts++
+	for ; _nacts > 0; _nacts-- {
+		 _acts++
+		switch _graphclust_actions[_acts - 1] {
+		case 4:
+// line 1 "NONE"
+
+ts = p
+
+// line 5008 "grapheme_clusters.go"
+		}
+	}
+
+	_keys = int(_graphclust_key_offsets[cs])
+	_trans = int(_graphclust_index_offsets[cs])
+
+	_klen = int(_graphclust_single_lengths[cs])
+	if _klen > 0 {
+		_lower := int(_keys)
+		var _mid int
+		_upper := int(_keys + _klen - 1)
+		for {
+			if _upper < _lower {
+				break
+			}
+
+			_mid = _lower + ((_upper - _lower) >> 1)
+			switch {
+			case data[p] < _graphclust_trans_keys[_mid]:
+				_upper = _mid - 1
+			case data[p] > _graphclust_trans_keys[_mid]:
+				_lower = _mid + 1
+			default:
+				_trans += int(_mid - int(_keys))
+				goto _match
+			}
+		}
+		_keys += _klen
+		_trans += _klen
+	}
+
+	_klen = int(_graphclust_range_lengths[cs])
+	if _klen > 0 {
+		_lower := int(_keys)
+		var _mid int
+		_upper := int(_keys + (_klen << 1) - 2)
+		for {
+			if _upper < _lower {
+				break
+			}
+
+			_mid = _lower + (((_upper - _lower) >> 1) & ^1)
+			switch {
+			case data[p] < _graphclust_trans_keys[_mid]:
+				_upper = _mid - 2
+			case data[p] > _graphclust_trans_keys[_mid + 1]:
+				_lower = _mid + 2
+			default:
+				_trans += int((_mid - int(_keys)) >> 1)
+				goto _match
+			}
+		}
+		_trans += _klen
+	}
+
+_match:
+	_trans = int(_graphclust_indicies[_trans])
+_eof_trans:
+	cs = int(_graphclust_trans_targs[_trans])
+
+	if _graphclust_trans_actions[_trans] == 0 {
+		goto _again
+	}
+
+	_acts = int(_graphclust_trans_actions[_trans])
+	_nacts = uint(_graphclust_actions[_acts]); _acts++
+	for ; _nacts > 0; _nacts-- {
+		_acts++
+		switch _graphclust_actions[_acts-1] {
+		case 0:
+// line 46 "grapheme_clusters.rl"
+
+
+            startPos = p
+        
+		case 1:
+// line 50 "grapheme_clusters.rl"
+
+
+            endPos = p
+        
+		case 5:
+// line 1 "NONE"
+
+te = p+1
+
+		case 6:
+// line 54 "grapheme_clusters.rl"
+
+act = 3;
+		case 7:
+// line 54 "grapheme_clusters.rl"
+
+te = p+1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 8:
+// line 54 "grapheme_clusters.rl"
+
+te = p+1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 9:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 10:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 11:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 12:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 13:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 14:
+// line 54 "grapheme_clusters.rl"
+
+te = p
+p--
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 15:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 16:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 17:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 18:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 19:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 20:
+// line 54 "grapheme_clusters.rl"
+
+p = (te) - 1
+{
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+		case 21:
+// line 1 "NONE"
+
+	switch act {
+	case 0:
+	{cs = 0
+goto _again
+}
+	case 3:
+	{p = (te) - 1
+
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+	}
+	
+// line 5218 "grapheme_clusters.go"
+		}
+	}
+
+_again:
+	_acts = int(_graphclust_to_state_actions[cs])
+	_nacts = uint(_graphclust_actions[_acts]); _acts++
+	for ; _nacts > 0; _nacts-- {
+		_acts++
+		switch _graphclust_actions[_acts-1] {
+		case 2:
+// line 1 "NONE"
+
+ts = 0
+
+		case 3:
+// line 1 "NONE"
+
+act = 0
+
+// line 5238 "grapheme_clusters.go"
+		}
+	}
+
+	if cs == 0 {
+		goto _out
+	}
+	p++
+	if p != pe {
+		goto _resume
+	}
+	_test_eof: {}
+	if p == eof {
+		if _graphclust_eof_trans[cs] > 0 {
+			_trans = int(_graphclust_eof_trans[cs] - 1)
+			goto _eof_trans
+		}
+	}
+
+	_out: {}
+	}
+
+// line 116 "grapheme_clusters.rl"
+
+
+    // If we fall out here then we were unable to complete a sequence.
+    // If we weren't able to complete a sequence then either we've
+    // reached the end of a partial buffer (so there's more data to come)
+    // or we have an isolated symbol that would normally be part of a
+    // grapheme cluster but has appeared in isolation here.
+
+    if !atEOF {
+        // Request more
+        return 0, nil, nil
+    }
+
+    // Just take the first UTF-8 sequence and return that.
+    _, seqLen := utf8.DecodeRune(data)
+    return seqLen, data[:seqLen], nil
+}
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.rl b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.rl
new file mode 100644
index 000000000..003ffbf59
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters.rl
@@ -0,0 +1,132 @@
+package textseg
+
+import (
+    "errors"
+    "unicode/utf8"
+)
+
+// Generated from grapheme_clusters.rl. DO NOT EDIT
+%%{
+  # (except you are actually in grapheme_clusters.rl here, so edit away!)
+
+  machine graphclust;
+  write data;
+}%%
+
+var Error = errors.New("invalid UTF8 text")
+
+// ScanGraphemeClusters is a split function for bufio.Scanner that splits
+// on grapheme cluster boundaries.
+func ScanGraphemeClusters(data []byte, atEOF bool) (int, []byte, error) {
+    if len(data) == 0 {
+        return 0, nil, nil
+    }
+
+    // Ragel state
+	cs := 0 // Current State
+	p := 0  // "Pointer" into data
+	pe := len(data) // End-of-data "pointer"
+    ts := 0
+    te := 0
+    act := 0
+    eof := pe
+
+    // Make Go compiler happy
+    _ = ts
+    _ = te
+    _ = act
+    _ = eof
+
+    startPos := 0
+    endPos := 0
+
+    %%{
+        include GraphemeCluster "grapheme_clusters_table.rl";
+
+        action start {
+            startPos = p
+        }
+
+        action end {
+            endPos = p
+        }
+
+        action emit {
+            return endPos+1, data[startPos:endPos+1], nil
+        }
+
+        ZWJGlue = ZWJ (Glue_After_Zwj | E_Base_GAZ Extend* E_Modifier?)?;
+        AnyExtender = Extend | ZWJGlue | SpacingMark;
+        Extension = AnyExtender*;
+        ReplacementChar = (0xEF 0xBF 0xBD);
+
+        CRLFSeq = CR LF;
+        ControlSeq = Control | ReplacementChar;
+        HangulSeq = (
+            L+ (((LV? V+ | LVT) T*)?|LV?) |
+            LV V* T* |
+            V+ T* |
+            LVT T* |
+            T+
+        ) Extension;
+        EmojiSeq = (E_Base | E_Base_GAZ) Extend* E_Modifier? Extension;
+        ZWJSeq = ZWJGlue Extension;
+        EmojiFlagSeq = Regional_Indicator Regional_Indicator? Extension;
+
+        UTF8Cont = 0x80 .. 0xBF;
+        AnyUTF8 = (
+            0x00..0x7F |
+            0xC0..0xDF . UTF8Cont |
+            0xE0..0xEF . UTF8Cont . UTF8Cont |
+            0xF0..0xF7 . UTF8Cont . UTF8Cont . UTF8Cont
+        );
+
+        # OtherSeq is any character that isn't at the start of one of the extended sequences above, followed by extension
+        OtherSeq = (AnyUTF8 - (CR|LF|Control|ReplacementChar|L|LV|V|LVT|T|E_Base|E_Base_GAZ|ZWJ|Regional_Indicator|Prepend)) Extension;
+
+        # PrependSeq is prepend followed by any of the other patterns above, except control characters which explicitly break
+        PrependSeq = Prepend+ (HangulSeq|EmojiSeq|ZWJSeq|EmojiFlagSeq|OtherSeq)?;
+
+        CRLFTok = CRLFSeq >start @end;
+        ControlTok = ControlSeq >start @end;
+        HangulTok = HangulSeq >start @end;
+        EmojiTok = EmojiSeq >start @end;
+        ZWJTok = ZWJSeq >start @end;
+        EmojiFlagTok = EmojiFlagSeq >start @end;
+        OtherTok = OtherSeq >start @end;
+        PrependTok = PrependSeq >start @end;
+
+        main := |*
+            CRLFTok => emit;
+            ControlTok => emit;
+            HangulTok => emit;
+            EmojiTok => emit;
+            ZWJTok => emit;
+            EmojiFlagTok => emit;
+            PrependTok => emit;
+            OtherTok => emit;
+
+            # any single valid UTF-8 character would also be valid per spec,
+            # but we'll handle that separately after the loop so we can deal
+            # with requesting more bytes if we're not at EOF.
+        *|;
+
+        write init;
+        write exec;
+    }%%
+
+    // If we fall out here then we were unable to complete a sequence.
+    // If we weren't able to complete a sequence then either we've
+    // reached the end of a partial buffer (so there's more data to come)
+    // or we have an isolated symbol that would normally be part of a
+    // grapheme cluster but has appeared in isolation here.
+
+    if !atEOF {
+        // Request more
+        return 0, nil, nil
+    }
+
+    // Just take the first UTF-8 sequence and return that.
+    _, seqLen := utf8.DecodeRune(data)
+    return seqLen, data[:seqLen], nil
+}
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters_table.rl b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters_table.rl
new file mode 100644
index 000000000..fb4511825
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/grapheme_clusters_table.rl
@@ -0,0 +1,1583 @@
+# The following Ragel file was autogenerated with unicode2ragel.rb 
+# from: http://www.unicode.org/Public/9.0.0/ucd/auxiliary/GraphemeBreakProperty.txt
+#
+# It defines ["Prepend", "CR", "LF", "Control", "Extend", "Regional_Indicator", "SpacingMark", "L", "V", "T", "LV", "LVT", "E_Base", "E_Modifier", "ZWJ", "Glue_After_Zwj", "E_Base_GAZ"].
+#
+# To use this, make sure that your alphtype is set to byte,
+# and that your input is in utf8.
+
+%%{
+    machine GraphemeCluster;
+    
+    Prepend = 
+        0xD8 0x80..0x85         #Cf   [6] ARABIC NUMBER SIGN..ARABIC NUMBER ...
+      | 0xDB 0x9D               #Cf       ARABIC END OF AYAH
+      | 0xDC 0x8F               #Cf       SYRIAC ABBREVIATION MARK
+      | 0xE0 0xA3 0xA2          #Cf       ARABIC DISPUTED END OF AYAH
+      | 0xE0 0xB5 0x8E          #Lo       MALAYALAM LETTER DOT REPH
+      | 0xF0 0x91 0x82 0xBD     #Cf       KAITHI NUMBER SIGN
+      | 0xF0 0x91 0x87 0x82..0x83  #Lo   [2] SHARADA SIGN JIHVAMULIYA..SHARA...
+      ;
+
+    CR = 
+        0x0D                    #Cc       <control-000D>
+      ;
+
+    LF = 
+        0x0A                    #Cc       <control-000A>
+      ;
+
+    Control = 
+        0x00..0x09              #Cc  [10] <control-0000>..<control-0009>
+      | 0x0B..0x0C              #Cc   [2] <control-000B>..<control-000C>
+      | 0x0E..0x1F              #Cc  [18] <control-000E>..<control-001F>
+      | 0x7F                    #Cc  [33] <control-007F>..<control-009F>
+      | 0xC2 0x80..0x9F         #
+      | 0xC2 0xAD               #Cf       SOFT HYPHEN
+      | 0xD8 0x9C               #Cf       ARABIC LETTER MARK
+      | 0xE1 0xA0 0x8E          #Cf       MONGOLIAN VOWEL SEPARATOR
+      | 0xE2 0x80 0x8B          #Cf       ZERO WIDTH SPACE
+      | 0xE2 0x80 0x8E..0x8F    #Cf   [2] LEFT-TO-RIGHT MARK..RIGHT-TO-LEFT ...
+      | 0xE2 0x80 0xA8          #Zl       LINE SEPARATOR
+      | 0xE2 0x80 0xA9          #Zp       PARAGRAPH SEPARATOR
+      | 0xE2 0x80 0xAA..0xAE    #Cf   [5] LEFT-TO-RIGHT EMBEDDING..RIGHT-TO-...
+      | 0xE2 0x81 0xA0..0xA4    #Cf   [5] WORD JOINER..INVISIBLE PLUS
+      | 0xE2 0x81 0xA5          #Cn       <reserved-2065>
+      | 0xE2 0x81 0xA6..0xAF    #Cf  [10] LEFT-TO-RIGHT ISOLATE..NOMINAL DIG...
+      | 0xED 0xA0 0x80..0xFF        #Cs [2048] <surrogate-D800>..<surrogate-...
+      | 0xED 0xA1..0xBE 0x00..0xFF  #
+      | 0xED 0xBF 0x00..0xBF        #
+      | 0xEF 0xBB 0xBF          #Cf       ZERO WIDTH NO-BREAK SPACE
+      | 0xEF 0xBF 0xB0..0xB8    #Cn   [9] <reserved-FFF0>..<reserved-FFF8>
+      | 0xEF 0xBF 0xB9..0xBB    #Cf   [3] INTERLINEAR ANNOTATION ANCHOR..INT...
+      | 0xF0 0x9B 0xB2 0xA0..0xA3  #Cf   [4] SHORTHAND FORMAT LETTER OVERLAP...
+      | 0xF0 0x9D 0x85 0xB3..0xBA  #Cf   [8] MUSICAL SYMBOL BEGIN BEAM..MUSI...
+      | 0xF3 0xA0 0x80 0x80     #Cn       <reserved-E0000>
+      | 0xF3 0xA0 0x80 0x81     #Cf       LANGUAGE TAG
+      | 0xF3 0xA0 0x80 0x82..0x9F  #Cn  [30] <reserved-E0002>..<reserved-E001F>
+      | 0xF3 0xA0 0x82 0x80..0xFF  #Cn [128] <reserved-E0080>..<reserved-E00FF>
+      | 0xF3 0xA0 0x83 0x00..0xBF  #
+      | 0xF3 0xA0 0x87 0xB0..0xFF        #Cn [3600] <reserved-E01F0>..<reser...
+      | 0xF3 0xA0 0x88..0xBE 0x00..0xFF  #
+      | 0xF3 0xA0 0xBF 0x00..0xBF        #
+      ;
+
+    Extend = 
+        0xCC 0x80..0xFF         #Mn [112] COMBINING GRAVE ACCENT..COMBINING ...
+      | 0xCD 0x00..0xAF         #
+      | 0xD2 0x83..0x87         #Mn   [5] COMBINING CYRILLIC TITLO..COMBININ...
+      | 0xD2 0x88..0x89         #Me   [2] COMBINING CYRILLIC HUNDRED THOUSAN...
+      | 0xD6 0x91..0xBD         #Mn  [45] HEBREW ACCENT ETNAHTA..HEBREW POIN...
+      | 0xD6 0xBF               #Mn       HEBREW POINT RAFE
+      | 0xD7 0x81..0x82         #Mn   [2] HEBREW POINT SHIN DOT..HEBREW POIN...
+      | 0xD7 0x84..0x85         #Mn   [2] HEBREW MARK UPPER DOT..HEBREW MARK...
+      | 0xD7 0x87               #Mn       HEBREW POINT QAMATS QATAN
+      | 0xD8 0x90..0x9A         #Mn  [11] ARABIC SIGN SALLALLAHOU ALAYHE WAS...
+      | 0xD9 0x8B..0x9F         #Mn  [21] ARABIC FATHATAN..ARABIC WAVY HAMZA...
+      | 0xD9 0xB0               #Mn       ARABIC LETTER SUPERSCRIPT ALEF
+      | 0xDB 0x96..0x9C         #Mn   [7] ARABIC SMALL HIGH LIGATURE SAD WIT...
+      | 0xDB 0x9F..0xA4         #Mn   [6] ARABIC SMALL HIGH ROUNDED ZERO..AR...
+      | 0xDB 0xA7..0xA8         #Mn   [2] ARABIC SMALL HIGH YEH..ARABIC SMAL...
+      | 0xDB 0xAA..0xAD         #Mn   [4] ARABIC EMPTY CENTRE LOW STOP..ARAB...
+      | 0xDC 0x91               #Mn       SYRIAC LETTER SUPERSCRIPT ALAPH
+      | 0xDC 0xB0..0xFF         #Mn  [27] SYRIAC PTHAHA ABOVE..SYRIAC BARREKH
+      | 0xDD 0x00..0x8A         #
+      | 0xDE 0xA6..0xB0         #Mn  [11] THAANA ABAFILI..THAANA SUKUN
+      | 0xDF 0xAB..0xB3         #Mn   [9] NKO COMBINING SHORT HIGH TONE..NKO...
+      | 0xE0 0xA0 0x96..0x99    #Mn   [4] SAMARITAN MARK IN..SAMARITAN MARK ...
+      | 0xE0 0xA0 0x9B..0xA3    #Mn   [9] SAMARITAN MARK EPENTHETIC YUT..SAM...
+      | 0xE0 0xA0 0xA5..0xA7    #Mn   [3] SAMARITAN VOWEL SIGN SHORT A..SAMA...
+      | 0xE0 0xA0 0xA9..0xAD    #Mn   [5] SAMARITAN VOWEL SIGN LONG I..SAMAR...
+      | 0xE0 0xA1 0x99..0x9B    #Mn   [3] MANDAIC AFFRICATION MARK..MANDAIC ...
+      | 0xE0 0xA3 0x94..0xA1    #Mn  [14] ARABIC SMALL HIGH WORD AR-RUB..ARA...
+      | 0xE0 0xA3 0xA3..0xFF    #Mn  [32] ARABIC TURNED DAMMA BELOW..DEVANAG...
+      | 0xE0 0xA4 0x00..0x82    #
+      | 0xE0 0xA4 0xBA          #Mn       DEVANAGARI VOWEL SIGN OE
+      | 0xE0 0xA4 0xBC          #Mn       DEVANAGARI SIGN NUKTA
+      | 0xE0 0xA5 0x81..0x88    #Mn   [8] DEVANAGARI VOWEL SIGN U..DEVANAGAR...
+      | 0xE0 0xA5 0x8D          #Mn       DEVANAGARI SIGN VIRAMA
+      | 0xE0 0xA5 0x91..0x97    #Mn   [7] DEVANAGARI STRESS SIGN UDATTA..DEV...
+      | 0xE0 0xA5 0xA2..0xA3    #Mn   [2] DEVANAGARI VOWEL SIGN VOCALIC L..D...
+      | 0xE0 0xA6 0x81          #Mn       BENGALI SIGN CANDRABINDU
+      | 0xE0 0xA6 0xBC          #Mn       BENGALI SIGN NUKTA
+      | 0xE0 0xA6 0xBE          #Mc       BENGALI VOWEL SIGN AA
+      | 0xE0 0xA7 0x81..0x84    #Mn   [4] BENGALI VOWEL SIGN U..BENGALI VOWE...
+      | 0xE0 0xA7 0x8D          #Mn       BENGALI SIGN VIRAMA
+      | 0xE0 0xA7 0x97          #Mc       BENGALI AU LENGTH MARK
+      | 0xE0 0xA7 0xA2..0xA3    #Mn   [2] BENGALI VOWEL SIGN VOCALIC L..BENG...
+      | 0xE0 0xA8 0x81..0x82    #Mn   [2] GURMUKHI SIGN ADAK BINDI..GURMUKHI...
+      | 0xE0 0xA8 0xBC          #Mn       GURMUKHI SIGN NUKTA
+      | 0xE0 0xA9 0x81..0x82    #Mn   [2] GURMUKHI VOWEL SIGN U..GURMUKHI VO...
+      | 0xE0 0xA9 0x87..0x88    #Mn   [2] GURMUKHI VOWEL SIGN EE..GURMUKHI V...
+      | 0xE0 0xA9 0x8B..0x8D    #Mn   [3] GURMUKHI VOWEL SIGN OO..GURMUKHI S...
+      | 0xE0 0xA9 0x91          #Mn       GURMUKHI SIGN UDAAT
+      | 0xE0 0xA9 0xB0..0xB1    #Mn   [2] GURMUKHI TIPPI..GURMUKHI ADDAK
+      | 0xE0 0xA9 0xB5          #Mn       GURMUKHI SIGN YAKASH
+      | 0xE0 0xAA 0x81..0x82    #Mn   [2] GUJARATI SIGN CANDRABINDU..GUJARAT...
+      | 0xE0 0xAA 0xBC          #Mn       GUJARATI SIGN NUKTA
+      | 0xE0 0xAB 0x81..0x85    #Mn   [5] GUJARATI VOWEL SIGN U..GUJARATI VO...
+      | 0xE0 0xAB 0x87..0x88    #Mn   [2] GUJARATI VOWEL SIGN E..GUJARATI VO...
+      | 0xE0 0xAB 0x8D          #Mn       GUJARATI SIGN VIRAMA
+      | 0xE0 0xAB 0xA2..0xA3    #Mn   [2] GUJARATI VOWEL SIGN VOCALIC L..GUJ...
+      | 0xE0 0xAC 0x81          #Mn       ORIYA SIGN CANDRABINDU
+      | 0xE0 0xAC 0xBC          #Mn       ORIYA SIGN NUKTA
+      | 0xE0 0xAC 0xBE          #Mc       ORIYA VOWEL SIGN AA
+      | 0xE0 0xAC 0xBF          #Mn       ORIYA VOWEL SIGN I
+      | 0xE0 0xAD 0x81..0x84    #Mn   [4] ORIYA VOWEL SIGN U..ORIYA VOWEL SI...
+      | 0xE0 0xAD 0x8D          #Mn       ORIYA SIGN VIRAMA
+      | 0xE0 0xAD 0x96          #Mn       ORIYA AI LENGTH MARK
+      | 0xE0 0xAD 0x97          #Mc       ORIYA AU LENGTH MARK
+      | 0xE0 0xAD 0xA2..0xA3    #Mn   [2] ORIYA VOWEL SIGN VOCALIC L..ORIYA ...
+      | 0xE0 0xAE 0x82          #Mn       TAMIL SIGN ANUSVARA
+      | 0xE0 0xAE 0xBE          #Mc       TAMIL VOWEL SIGN AA
+      | 0xE0 0xAF 0x80          #Mn       TAMIL VOWEL SIGN II
+      | 0xE0 0xAF 0x8D          #Mn       TAMIL SIGN VIRAMA
+      | 0xE0 0xAF 0x97          #Mc       TAMIL AU LENGTH MARK
+      | 0xE0 0xB0 0x80          #Mn       TELUGU SIGN COMBINING CANDRABINDU ...
+      | 0xE0 0xB0 0xBE..0xFF    #Mn   [3] TELUGU VOWEL SIGN AA..TELUGU VOWEL...
+      | 0xE0 0xB1 0x00..0x80    #
+      | 0xE0 0xB1 0x86..0x88    #Mn   [3] TELUGU VOWEL SIGN E..TELUGU VOWEL ...
+      | 0xE0 0xB1 0x8A..0x8D    #Mn   [4] TELUGU VOWEL SIGN O..TELUGU SIGN V...
+      | 0xE0 0xB1 0x95..0x96    #Mn   [2] TELUGU LENGTH MARK..TELUGU AI LENG...
+      | 0xE0 0xB1 0xA2..0xA3    #Mn   [2] TELUGU VOWEL SIGN VOCALIC L..TELUG...
+      | 0xE0 0xB2 0x81          #Mn       KANNADA SIGN CANDRABINDU
+      | 0xE0 0xB2 0xBC          #Mn       KANNADA SIGN NUKTA
+      | 0xE0 0xB2 0xBF          #Mn       KANNADA VOWEL SIGN I
+      | 0xE0 0xB3 0x82          #Mc       KANNADA VOWEL SIGN UU
+      | 0xE0 0xB3 0x86          #Mn       KANNADA VOWEL SIGN E
+      | 0xE0 0xB3 0x8C..0x8D    #Mn   [2] KANNADA VOWEL SIGN AU..KANNADA SIG...
+      | 0xE0 0xB3 0x95..0x96    #Mc   [2] KANNADA LENGTH MARK..KANNADA AI LE...
+      | 0xE0 0xB3 0xA2..0xA3    #Mn   [2] KANNADA VOWEL SIGN VOCALIC L..KANN...
+      | 0xE0 0xB4 0x81          #Mn       MALAYALAM SIGN CANDRABINDU
+      | 0xE0 0xB4 0xBE          #Mc       MALAYALAM VOWEL SIGN AA
+      | 0xE0 0xB5 0x81..0x84    #Mn   [4] MALAYALAM VOWEL SIGN U..MALAYALAM ...
+      | 0xE0 0xB5 0x8D          #Mn       MALAYALAM SIGN VIRAMA
+      | 0xE0 0xB5 0x97          #Mc       MALAYALAM AU LENGTH MARK
+      | 0xE0 0xB5 0xA2..0xA3    #Mn   [2] MALAYALAM VOWEL SIGN VOCALIC L..MA...
+      | 0xE0 0xB7 0x8A          #Mn       SINHALA SIGN AL-LAKUNA
+      | 0xE0 0xB7 0x8F          #Mc       SINHALA VOWEL SIGN AELA-PILLA
+      | 0xE0 0xB7 0x92..0x94    #Mn   [3] SINHALA VOWEL SIGN KETTI IS-PILLA....
+      | 0xE0 0xB7 0x96          #Mn       SINHALA VOWEL SIGN DIGA PAA-PILLA
+      | 0xE0 0xB7 0x9F          #Mc       SINHALA VOWEL SIGN GAYANUKITTA
+      | 0xE0 0xB8 0xB1          #Mn       THAI CHARACTER MAI HAN-AKAT
+      | 0xE0 0xB8 0xB4..0xBA    #Mn   [7] THAI CHARACTER SARA I..THAI CHARAC...
+      | 0xE0 0xB9 0x87..0x8E    #Mn   [8] THAI CHARACTER MAITAIKHU..THAI CHA...
+      | 0xE0 0xBA 0xB1          #Mn       LAO VOWEL SIGN MAI KAN
+      | 0xE0 0xBA 0xB4..0xB9    #Mn   [6] LAO VOWEL SIGN I..LAO VOWEL SIGN UU
+      | 0xE0 0xBA 0xBB..0xBC    #Mn   [2] LAO VOWEL SIGN MAI KON..LAO SEMIVO...
+      | 0xE0 0xBB 0x88..0x8D    #Mn   [6] LAO TONE MAI EK..LAO NIGGAHITA
+      | 0xE0 0xBC 0x98..0x99    #Mn   [2] TIBETAN ASTROLOGICAL SIGN -KHYUD P...
+      | 0xE0 0xBC 0xB5          #Mn       TIBETAN MARK NGAS BZUNG NYI ZLA
+      | 0xE0 0xBC 0xB7          #Mn       TIBETAN MARK NGAS BZUNG SGOR RTAGS
+      | 0xE0 0xBC 0xB9          #Mn       TIBETAN MARK TSA -PHRU
+      | 0xE0 0xBD 0xB1..0xBE    #Mn  [14] TIBETAN VOWEL SIGN AA..TIBETAN SIG...
+      | 0xE0 0xBE 0x80..0x84    #Mn   [5] TIBETAN VOWEL SIGN REVERSED I..TIB...
+      | 0xE0 0xBE 0x86..0x87    #Mn   [2] TIBETAN SIGN LCI RTAGS..TIBETAN SI...
+      | 0xE0 0xBE 0x8D..0x97    #Mn  [11] TIBETAN SUBJOINED SIGN LCE TSA CAN...
+      | 0xE0 0xBE 0x99..0xBC    #Mn  [36] TIBETAN SUBJOINED LETTER NYA..TIBE...
+      | 0xE0 0xBF 0x86          #Mn       TIBETAN SYMBOL PADMA GDAN
+      | 0xE1 0x80 0xAD..0xB0    #Mn   [4] MYANMAR VOWEL SIGN I..MYANMAR VOWE...
+      | 0xE1 0x80 0xB2..0xB7    #Mn   [6] MYANMAR VOWEL SIGN AI..MYANMAR SIG...
+      | 0xE1 0x80 0xB9..0xBA    #Mn   [2] MYANMAR SIGN VIRAMA..MYANMAR SIGN ...
+      | 0xE1 0x80 0xBD..0xBE    #Mn   [2] MYANMAR CONSONANT SIGN MEDIAL WA.....
+      | 0xE1 0x81 0x98..0x99    #Mn   [2] MYANMAR VOWEL SIGN VOCALIC L..MYAN...
+      | 0xE1 0x81 0x9E..0xA0    #Mn   [3] MYANMAR CONSONANT SIGN MON MEDIAL ...
+      | 0xE1 0x81 0xB1..0xB4    #Mn   [4] MYANMAR VOWEL SIGN GEBA KAREN I..M...
+      | 0xE1 0x82 0x82          #Mn       MYANMAR CONSONANT SIGN SHAN MEDIAL WA
+      | 0xE1 0x82 0x85..0x86    #Mn   [2] MYANMAR VOWEL SIGN SHAN E ABOVE..M...
+      | 0xE1 0x82 0x8D          #Mn       MYANMAR SIGN SHAN COUNCIL EMPHATIC...
+      | 0xE1 0x82 0x9D          #Mn       MYANMAR VOWEL SIGN AITON AI
+      | 0xE1 0x8D 0x9D..0x9F    #Mn   [3] ETHIOPIC COMBINING GEMINATION AND ...
+      | 0xE1 0x9C 0x92..0x94    #Mn   [3] TAGALOG VOWEL SIGN I..TAGALOG SIGN...
+      | 0xE1 0x9C 0xB2..0xB4    #Mn   [3] HANUNOO VOWEL SIGN I..HANUNOO SIGN...
+      | 0xE1 0x9D 0x92..0x93    #Mn   [2] BUHID VOWEL SIGN I..BUHID VOWEL SI...
+      | 0xE1 0x9D 0xB2..0xB3    #Mn   [2] TAGBANWA VOWEL SIGN I..TAGBANWA VO...
+      | 0xE1 0x9E 0xB4..0xB5    #Mn   [2] KHMER VOWEL INHERENT AQ..KHMER VOW...
+      | 0xE1 0x9E 0xB7..0xBD    #Mn   [7] KHMER VOWEL SIGN I..KHMER VOWEL SI...
+      | 0xE1 0x9F 0x86          #Mn       KHMER SIGN NIKAHIT
+      | 0xE1 0x9F 0x89..0x93    #Mn  [11] KHMER SIGN MUUSIKATOAN..KHMER SIGN...
+      | 0xE1 0x9F 0x9D          #Mn       KHMER SIGN ATTHACAN
+      | 0xE1 0xA0 0x8B..0x8D    #Mn   [3] MONGOLIAN FREE VARIATION SELECTOR ...
+      | 0xE1 0xA2 0x85..0x86    #Mn   [2] MONGOLIAN LETTER ALI GALI BALUDA.....
+      | 0xE1 0xA2 0xA9          #Mn       MONGOLIAN LETTER ALI GALI DAGALGA
+      | 0xE1 0xA4 0xA0..0xA2    #Mn   [3] LIMBU VOWEL SIGN A..LIMBU VOWEL SI...
+      | 0xE1 0xA4 0xA7..0xA8    #Mn   [2] LIMBU VOWEL SIGN E..LIMBU VOWEL SI...
+      | 0xE1 0xA4 0xB2          #Mn       LIMBU SMALL LETTER ANUSVARA
+      | 0xE1 0xA4 0xB9..0xBB    #Mn   [3] LIMBU SIGN MUKPHRENG..LIMBU SIGN SA-I
+      | 0xE1 0xA8 0x97..0x98    #Mn   [2] BUGINESE VOWEL SIGN I..BUGINESE VO...
+      | 0xE1 0xA8 0x9B          #Mn       BUGINESE VOWEL SIGN AE
+      | 0xE1 0xA9 0x96          #Mn       TAI THAM CONSONANT SIGN MEDIAL LA
+      | 0xE1 0xA9 0x98..0x9E    #Mn   [7] TAI THAM SIGN MAI KANG LAI..TAI TH...
+      | 0xE1 0xA9 0xA0          #Mn       TAI THAM SIGN SAKOT
+      | 0xE1 0xA9 0xA2          #Mn       TAI THAM VOWEL SIGN MAI SAT
+      | 0xE1 0xA9 0xA5..0xAC    #Mn   [8] TAI THAM VOWEL SIGN I..TAI THAM VO...
+      | 0xE1 0xA9 0xB3..0xBC    #Mn  [10] TAI THAM VOWEL SIGN OA ABOVE..TAI ...
+      | 0xE1 0xA9 0xBF          #Mn       TAI THAM COMBINING CRYPTOGRAMMIC DOT
+      | 0xE1 0xAA 0xB0..0xBD    #Mn  [14] COMBINING DOUBLED CIRCUMFLEX ACCEN...
+      | 0xE1 0xAA 0xBE          #Me       COMBINING PARENTHESES OVERLAY
+      | 0xE1 0xAC 0x80..0x83    #Mn   [4] BALINESE SIGN ULU RICEM..BALINESE ...
+      | 0xE1 0xAC 0xB4          #Mn       BALINESE SIGN REREKAN
+      | 0xE1 0xAC 0xB6..0xBA    #Mn   [5] BALINESE VOWEL SIGN ULU..BALINESE ...
+      | 0xE1 0xAC 0xBC          #Mn       BALINESE VOWEL SIGN LA LENGA
+      | 0xE1 0xAD 0x82          #Mn       BALINESE VOWEL SIGN PEPET
+      | 0xE1 0xAD 0xAB..0xB3    #Mn   [9] BALINESE MUSICAL SYMBOL COMBINING ...
+      | 0xE1 0xAE 0x80..0x81    #Mn   [2] SUNDANESE SIGN PANYECEK..SUNDANESE...
+      | 0xE1 0xAE 0xA2..0xA5    #Mn   [4] SUNDANESE CONSONANT SIGN PANYAKRA....
+      | 0xE1 0xAE 0xA8..0xA9    #Mn   [2] SUNDANESE VOWEL SIGN PAMEPET..SUND...
+      | 0xE1 0xAE 0xAB..0xAD    #Mn   [3] SUNDANESE SIGN VIRAMA..SUNDANESE C...
+      | 0xE1 0xAF 0xA6          #Mn       BATAK SIGN TOMPI
+      | 0xE1 0xAF 0xA8..0xA9    #Mn   [2] BATAK VOWEL SIGN PAKPAK E..BATAK V...
+      | 0xE1 0xAF 0xAD          #Mn       BATAK VOWEL SIGN KARO O
+      | 0xE1 0xAF 0xAF..0xB1    #Mn   [3] BATAK VOWEL SIGN U FOR SIMALUNGUN ...
+      | 0xE1 0xB0 0xAC..0xB3    #Mn   [8] LEPCHA VOWEL SIGN E..LEPCHA CONSON...
+      | 0xE1 0xB0 0xB6..0xB7    #Mn   [2] LEPCHA SIGN RAN..LEPCHA SIGN NUKTA
+      | 0xE1 0xB3 0x90..0x92    #Mn   [3] VEDIC TONE KARSHANA..VEDIC TONE PR...
+      | 0xE1 0xB3 0x94..0xA0    #Mn  [13] VEDIC SIGN YAJURVEDIC MIDLINE SVAR...
+      | 0xE1 0xB3 0xA2..0xA8    #Mn   [7] VEDIC SIGN VISARGA SVARITA..VEDIC ...
+      | 0xE1 0xB3 0xAD          #Mn       VEDIC SIGN TIRYAK
+      | 0xE1 0xB3 0xB4          #Mn       VEDIC TONE CANDRA ABOVE
+      | 0xE1 0xB3 0xB8..0xB9    #Mn   [2] VEDIC TONE RING ABOVE..VEDIC TONE ...
+      | 0xE1 0xB7 0x80..0xB5    #Mn  [54] COMBINING DOTTED GRAVE ACCENT..COM...
+      | 0xE1 0xB7 0xBB..0xBF    #Mn   [5] COMBINING DELETION MARK..COMBINING...
+      | 0xE2 0x80 0x8C          #Cf       ZERO WIDTH NON-JOINER
+      | 0xE2 0x83 0x90..0x9C    #Mn  [13] COMBINING LEFT HARPOON ABOVE..COMB...
+      | 0xE2 0x83 0x9D..0xA0    #Me   [4] COMBINING ENCLOSING CIRCLE..COMBIN...
+      | 0xE2 0x83 0xA1          #Mn       COMBINING LEFT RIGHT ARROW ABOVE
+      | 0xE2 0x83 0xA2..0xA4    #Me   [3] COMBINING ENCLOSING SCREEN..COMBIN...
+      | 0xE2 0x83 0xA5..0xB0    #Mn  [12] COMBINING REVERSE SOLIDUS OVERLAY....
+      | 0xE2 0xB3 0xAF..0xB1    #Mn   [3] COPTIC COMBINING NI ABOVE..COPTIC ...
+      | 0xE2 0xB5 0xBF          #Mn       TIFINAGH CONSONANT JOINER
+      | 0xE2 0xB7 0xA0..0xBF    #Mn  [32] COMBINING CYRILLIC LETTER BE..COMB...
+      | 0xE3 0x80 0xAA..0xAD    #Mn   [4] IDEOGRAPHIC LEVEL TONE MARK..IDEOG...
+      | 0xE3 0x80 0xAE..0xAF    #Mc   [2] HANGUL SINGLE DOT TONE MARK..HANGU...
+      | 0xE3 0x82 0x99..0x9A    #Mn   [2] COMBINING KATAKANA-HIRAGANA VOICED...
+      | 0xEA 0x99 0xAF          #Mn       COMBINING CYRILLIC VZMET
+      | 0xEA 0x99 0xB0..0xB2    #Me   [3] COMBINING CYRILLIC TEN MILLIONS SI...
+      | 0xEA 0x99 0xB4..0xBD    #Mn  [10] COMBINING CYRILLIC LETTER UKRAINIA...
+      | 0xEA 0x9A 0x9E..0x9F    #Mn   [2] COMBINING CYRILLIC LETTER EF..COMB...
+      | 0xEA 0x9B 0xB0..0xB1    #Mn   [2] BAMUM COMBINING MARK KOQNDON..BAMU...
+      | 0xEA 0xA0 0x82          #Mn       SYLOTI NAGRI SIGN DVISVARA
+      | 0xEA 0xA0 0x86          #Mn       SYLOTI NAGRI SIGN HASANTA
+      | 0xEA 0xA0 0x8B          #Mn       SYLOTI NAGRI SIGN ANUSVARA
+      | 0xEA 0xA0 0xA5..0xA6    #Mn   [2] SYLOTI NAGRI VOWEL SIGN U..SYLOTI ...
+      | 0xEA 0xA3 0x84..0x85    #Mn   [2] SAURASHTRA SIGN VIRAMA..SAURASHTRA...
+      | 0xEA 0xA3 0xA0..0xB1    #Mn  [18] COMBINING DEVANAGARI DIGIT ZERO..C...
+      | 0xEA 0xA4 0xA6..0xAD    #Mn   [8] KAYAH LI VOWEL UE..KAYAH LI TONE C...
+      | 0xEA 0xA5 0x87..0x91    #Mn  [11] REJANG VOWEL SIGN I..REJANG CONSON...
+      | 0xEA 0xA6 0x80..0x82    #Mn   [3] JAVANESE SIGN PANYANGGA..JAVANESE ...
+      | 0xEA 0xA6 0xB3          #Mn       JAVANESE SIGN CECAK TELU
+      | 0xEA 0xA6 0xB6..0xB9    #Mn   [4] JAVANESE VOWEL SIGN WULU..JAVANESE...
+      | 0xEA 0xA6 0xBC          #Mn       JAVANESE VOWEL SIGN PEPET
+      | 0xEA 0xA7 0xA5          #Mn       MYANMAR SIGN SHAN SAW
+      | 0xEA 0xA8 0xA9..0xAE    #Mn   [6] CHAM VOWEL SIGN AA..CHAM VOWEL SIG...
+      | 0xEA 0xA8 0xB1..0xB2    #Mn   [2] CHAM VOWEL SIGN AU..CHAM VOWEL SIG...
+      | 0xEA 0xA8 0xB5..0xB6    #Mn   [2] CHAM CONSONANT SIGN LA..CHAM CONSO...
+      | 0xEA 0xA9 0x83          #Mn       CHAM CONSONANT SIGN FINAL NG
+      | 0xEA 0xA9 0x8C          #Mn       CHAM CONSONANT SIGN FINAL M
+      | 0xEA 0xA9 0xBC          #Mn       MYANMAR SIGN TAI LAING TONE-2
+      | 0xEA 0xAA 0xB0          #Mn       TAI VIET MAI KANG
+      | 0xEA 0xAA 0xB2..0xB4    #Mn   [3] TAI VIET VOWEL I..TAI VIET VOWEL U
+      | 0xEA 0xAA 0xB7..0xB8    #Mn   [2] TAI VIET MAI KHIT..TAI VIET VOWEL IA
+      | 0xEA 0xAA 0xBE..0xBF    #Mn   [2] TAI VIET VOWEL AM..TAI VIET TONE M...
+      | 0xEA 0xAB 0x81          #Mn       TAI VIET TONE MAI THO
+      | 0xEA 0xAB 0xAC..0xAD    #Mn   [2] MEETEI MAYEK VOWEL SIGN UU..MEETEI...
+      | 0xEA 0xAB 0xB6          #Mn       MEETEI MAYEK VIRAMA
+      | 0xEA 0xAF 0xA5          #Mn       MEETEI MAYEK VOWEL SIGN ANAP
+      | 0xEA 0xAF 0xA8          #Mn       MEETEI MAYEK VOWEL SIGN UNAP
+      | 0xEA 0xAF 0xAD          #Mn       MEETEI MAYEK APUN IYEK
+      | 0xEF 0xAC 0x9E          #Mn       HEBREW POINT JUDEO-SPANISH VARIKA
+      | 0xEF 0xB8 0x80..0x8F    #Mn  [16] VARIATION SELECTOR-1..VARIATION SE...
+      | 0xEF 0xB8 0xA0..0xAF    #Mn  [16] COMBINING LIGATURE LEFT HALF..COMB...
+      | 0xEF 0xBE 0x9E..0x9F    #Lm   [2] HALFWIDTH KATAKANA VOICED SOUND MA...
+      | 0xF0 0x90 0x87 0xBD     #Mn       PHAISTOS DISC SIGN COMBINING OBLIQ...
+      | 0xF0 0x90 0x8B 0xA0     #Mn       COPTIC EPACT THOUSANDS MARK
+      | 0xF0 0x90 0x8D 0xB6..0xBA  #Mn   [5] COMBINING OLD PERMIC LETTER AN....
+      | 0xF0 0x90 0xA8 0x81..0x83  #Mn   [3] KHAROSHTHI VOWEL SIGN I..KHAROS...
+      | 0xF0 0x90 0xA8 0x85..0x86  #Mn   [2] KHAROSHTHI VOWEL SIGN E..KHAROS...
+      | 0xF0 0x90 0xA8 0x8C..0x8F  #Mn   [4] KHAROSHTHI VOWEL LENGTH MARK..K...
+      | 0xF0 0x90 0xA8 0xB8..0xBA  #Mn   [3] KHAROSHTHI SIGN BAR ABOVE..KHAR...
+      | 0xF0 0x90 0xA8 0xBF     #Mn       KHAROSHTHI VIRAMA
+      | 0xF0 0x90 0xAB 0xA5..0xA6  #Mn   [2] MANICHAEAN ABBREVIATION MARK AB...
+      | 0xF0 0x91 0x80 0x81     #Mn       BRAHMI SIGN ANUSVARA
+      | 0xF0 0x91 0x80 0xB8..0xFF  #Mn  [15] BRAHMI VOWEL SIGN AA..BRAHMI VI...
+      | 0xF0 0x91 0x81 0x00..0x86  #
+      | 0xF0 0x91 0x81 0xBF..0xFF  #Mn   [3] BRAHMI NUMBER JOINER..KAITHI SI...
+      | 0xF0 0x91 0x82 0x00..0x81  #
+      | 0xF0 0x91 0x82 0xB3..0xB6  #Mn   [4] KAITHI VOWEL SIGN U..KAITHI VOW...
+      | 0xF0 0x91 0x82 0xB9..0xBA  #Mn   [2] KAITHI SIGN VIRAMA..KAITHI SIGN...
+      | 0xF0 0x91 0x84 0x80..0x82  #Mn   [3] CHAKMA SIGN CANDRABINDU..CHAKMA...
+      | 0xF0 0x91 0x84 0xA7..0xAB  #Mn   [5] CHAKMA VOWEL SIGN A..CHAKMA VOW...
+      | 0xF0 0x91 0x84 0xAD..0xB4  #Mn   [8] CHAKMA VOWEL SIGN AI..CHAKMA MA...
+      | 0xF0 0x91 0x85 0xB3     #Mn       MAHAJANI SIGN NUKTA
+      | 0xF0 0x91 0x86 0x80..0x81  #Mn   [2] SHARADA SIGN CANDRABINDU..SHARA...
+      | 0xF0 0x91 0x86 0xB6..0xBE  #Mn   [9] SHARADA VOWEL SIGN U..SHARADA V...
+      | 0xF0 0x91 0x87 0x8A..0x8C  #Mn   [3] SHARADA SIGN NUKTA..SHARADA EXT...
+      | 0xF0 0x91 0x88 0xAF..0xB1  #Mn   [3] KHOJKI VOWEL SIGN U..KHOJKI VOW...
+      | 0xF0 0x91 0x88 0xB4     #Mn       KHOJKI SIGN ANUSVARA
+      | 0xF0 0x91 0x88 0xB6..0xB7  #Mn   [2] KHOJKI SIGN NUKTA..KHOJKI SIGN ...
+      | 0xF0 0x91 0x88 0xBE     #Mn       KHOJKI SIGN SUKUN
+      | 0xF0 0x91 0x8B 0x9F     #Mn       KHUDAWADI SIGN ANUSVARA
+      | 0xF0 0x91 0x8B 0xA3..0xAA  #Mn   [8] KHUDAWADI VOWEL SIGN U..KHUDAWA...
+      | 0xF0 0x91 0x8C 0x80..0x81  #Mn   [2] GRANTHA SIGN COMBINING ANUSVARA...
+      | 0xF0 0x91 0x8C 0xBC     #Mn       GRANTHA SIGN NUKTA
+      | 0xF0 0x91 0x8C 0xBE     #Mc       GRANTHA VOWEL SIGN AA
+      | 0xF0 0x91 0x8D 0x80     #Mn       GRANTHA VOWEL SIGN II
+      | 0xF0 0x91 0x8D 0x97     #Mc       GRANTHA AU LENGTH MARK
+      | 0xF0 0x91 0x8D 0xA6..0xAC  #Mn   [7] COMBINING GRANTHA DIGIT ZERO..C...
+      | 0xF0 0x91 0x8D 0xB0..0xB4  #Mn   [5] COMBINING GRANTHA LETTER A..COM...
+      | 0xF0 0x91 0x90 0xB8..0xBF  #Mn   [8] NEWA VOWEL SIGN U..NEWA VOWEL S...
+      | 0xF0 0x91 0x91 0x82..0x84  #Mn   [3] NEWA SIGN VIRAMA..NEWA SIGN ANU...
+      | 0xF0 0x91 0x91 0x86     #Mn       NEWA SIGN NUKTA
+      | 0xF0 0x91 0x92 0xB0     #Mc       TIRHUTA VOWEL SIGN AA
+      | 0xF0 0x91 0x92 0xB3..0xB8  #Mn   [6] TIRHUTA VOWEL SIGN U..TIRHUTA V...
+      | 0xF0 0x91 0x92 0xBA     #Mn       TIRHUTA VOWEL SIGN SHORT E
+      | 0xF0 0x91 0x92 0xBD     #Mc       TIRHUTA VOWEL SIGN SHORT O
+      | 0xF0 0x91 0x92 0xBF..0xFF  #Mn   [2] TIRHUTA SIGN CANDRABINDU..TIRHU...
+      | 0xF0 0x91 0x93 0x00..0x80  #
+      | 0xF0 0x91 0x93 0x82..0x83  #Mn   [2] TIRHUTA SIGN VIRAMA..TIRHUTA SI...
+      | 0xF0 0x91 0x96 0xAF     #Mc       SIDDHAM VOWEL SIGN AA
+      | 0xF0 0x91 0x96 0xB2..0xB5  #Mn   [4] SIDDHAM VOWEL SIGN U..SIDDHAM V...
+      | 0xF0 0x91 0x96 0xBC..0xBD  #Mn   [2] SIDDHAM SIGN CANDRABINDU..SIDDH...
+      | 0xF0 0x91 0x96 0xBF..0xFF  #Mn   [2] SIDDHAM SIGN VIRAMA..SIDDHAM SI...
+      | 0xF0 0x91 0x97 0x00..0x80  #
+      | 0xF0 0x91 0x97 0x9C..0x9D  #Mn   [2] SIDDHAM VOWEL SIGN ALTERNATE U....
+      | 0xF0 0x91 0x98 0xB3..0xBA  #Mn   [8] MODI VOWEL SIGN U..MODI VOWEL S...
+      | 0xF0 0x91 0x98 0xBD     #Mn       MODI SIGN ANUSVARA
+      | 0xF0 0x91 0x98 0xBF..0xFF  #Mn   [2] MODI SIGN VIRAMA..MODI SIGN ARD...
+      | 0xF0 0x91 0x99 0x00..0x80  #
+      | 0xF0 0x91 0x9A 0xAB     #Mn       TAKRI SIGN ANUSVARA
+      | 0xF0 0x91 0x9A 0xAD     #Mn       TAKRI VOWEL SIGN AA
+      | 0xF0 0x91 0x9A 0xB0..0xB5  #Mn   [6] TAKRI VOWEL SIGN U..TAKRI VOWEL...
+      | 0xF0 0x91 0x9A 0xB7     #Mn       TAKRI SIGN NUKTA
+      | 0xF0 0x91 0x9C 0x9D..0x9F  #Mn   [3] AHOM CONSONANT SIGN MEDIAL LA.....
+      | 0xF0 0x91 0x9C 0xA2..0xA5  #Mn   [4] AHOM VOWEL SIGN I..AHOM VOWEL S...
+      | 0xF0 0x91 0x9C 0xA7..0xAB  #Mn   [5] AHOM VOWEL SIGN AW..AHOM SIGN K...
+      | 0xF0 0x91 0xB0 0xB0..0xB6  #Mn   [7] BHAIKSUKI VOWEL SIGN I..BHAIKSU...
+      | 0xF0 0x91 0xB0 0xB8..0xBD  #Mn   [6] BHAIKSUKI VOWEL SIGN E..BHAIKSU...
+      | 0xF0 0x91 0xB0 0xBF     #Mn       BHAIKSUKI SIGN VIRAMA
+      | 0xF0 0x91 0xB2 0x92..0xA7  #Mn  [22] MARCHEN SUBJOINED LETTER KA..MA...
+      | 0xF0 0x91 0xB2 0xAA..0xB0  #Mn   [7] MARCHEN SUBJOINED LETTER RA..MA...
+      | 0xF0 0x91 0xB2 0xB2..0xB3  #Mn   [2] MARCHEN VOWEL SIGN U..MARCHEN V...
+      | 0xF0 0x91 0xB2 0xB5..0xB6  #Mn   [2] MARCHEN SIGN ANUSVARA..MARCHEN ...
+      | 0xF0 0x96 0xAB 0xB0..0xB4  #Mn   [5] BASSA VAH COMBINING HIGH TONE.....
+      | 0xF0 0x96 0xAC 0xB0..0xB6  #Mn   [7] PAHAWH HMONG MARK CIM TUB..PAHA...
+      | 0xF0 0x96 0xBE 0x8F..0x92  #Mn   [4] MIAO TONE RIGHT..MIAO TONE BELOW
+      | 0xF0 0x9B 0xB2 0x9D..0x9E  #Mn   [2] DUPLOYAN THICK LETTER SELECTOR....
+      | 0xF0 0x9D 0x85 0xA5     #Mc       MUSICAL SYMBOL COMBINING STEM
+      | 0xF0 0x9D 0x85 0xA7..0xA9  #Mn   [3] MUSICAL SYMBOL COMBINING TREMOL...
+      | 0xF0 0x9D 0x85 0xAE..0xB2  #Mc   [5] MUSICAL SYMBOL COMBINING FLAG-1...
+      | 0xF0 0x9D 0x85 0xBB..0xFF  #Mn   [8] MUSICAL SYMBOL COMBINING ACCENT...
+      | 0xF0 0x9D 0x86 0x00..0x82  #
+      | 0xF0 0x9D 0x86 0x85..0x8B  #Mn   [7] MUSICAL SYMBOL COMBINING DOIT.....
+      | 0xF0 0x9D 0x86 0xAA..0xAD  #Mn   [4] MUSICAL SYMBOL COMBINING DOWN B...
+      | 0xF0 0x9D 0x89 0x82..0x84  #Mn   [3] COMBINING GREEK MUSICAL TRISEME...
+      | 0xF0 0x9D 0xA8 0x80..0xB6  #Mn  [55] SIGNWRITING HEAD RIM..SIGNWRITI...
+      | 0xF0 0x9D 0xA8 0xBB..0xFF  #Mn  [50] SIGNWRITING MOUTH CLOSED NEUTRA...
+      | 0xF0 0x9D 0xA9 0x00..0xAC  #
+      | 0xF0 0x9D 0xA9 0xB5     #Mn       SIGNWRITING UPPER BODY TILTING FRO...
+      | 0xF0 0x9D 0xAA 0x84     #Mn       SIGNWRITING LOCATION HEAD NECK
+      | 0xF0 0x9D 0xAA 0x9B..0x9F  #Mn   [5] SIGNWRITING FILL MODIFIER-2..SI...
+      | 0xF0 0x9D 0xAA 0xA1..0xAF  #Mn  [15] SIGNWRITING ROTATION MODIFIER-2...
+      | 0xF0 0x9E 0x80 0x80..0x86  #Mn   [7] COMBINING GLAGOLITIC LETTER AZU...
+      | 0xF0 0x9E 0x80 0x88..0x98  #Mn  [17] COMBINING GLAGOLITIC LETTER ZEM...
+      | 0xF0 0x9E 0x80 0x9B..0xA1  #Mn   [7] COMBINING GLAGOLITIC LETTER SHT...
+      | 0xF0 0x9E 0x80 0xA3..0xA4  #Mn   [2] COMBINING GLAGOLITIC LETTER YU....
+      | 0xF0 0x9E 0x80 0xA6..0xAA  #Mn   [5] COMBINING GLAGOLITIC LETTER YO....
+      | 0xF0 0x9E 0xA3 0x90..0x96  #Mn   [7] MENDE KIKAKUI COMBINING NUMBER ...
+      | 0xF0 0x9E 0xA5 0x84..0x8A  #Mn   [7] ADLAM ALIF LENGTHENER..ADLAM NUKTA
+      | 0xF3 0xA0 0x80 0xA0..0xFF  #Cf  [96] TAG SPACE..CANCEL TAG
+      | 0xF3 0xA0 0x81 0x00..0xBF  #
+      | 0xF3 0xA0 0x84 0x80..0xFF        #Mn [240] VARIATION SELECTOR-17..VA...
+      | 0xF3 0xA0 0x85..0x86 0x00..0xFF  #
+      | 0xF3 0xA0 0x87 0x00..0xAF        #
+      ;
+
+    Regional_Indicator = 
+        0xF0 0x9F 0x87 0xA6..0xBF  #So  [26] REGIONAL INDICATOR SYMBOL LETTE...
+      ;
+
+    SpacingMark = 
+        0xE0 0xA4 0x83          #Mc       DEVANAGARI SIGN VISARGA
+      | 0xE0 0xA4 0xBB          #Mc       DEVANAGARI VOWEL SIGN OOE
+      | 0xE0 0xA4 0xBE..0xFF    #Mc   [3] DEVANAGARI VOWEL SIGN AA..DEVANAGA...
+      | 0xE0 0xA5 0x00..0x80    #
+      | 0xE0 0xA5 0x89..0x8C    #Mc   [4] DEVANAGARI VOWEL SIGN CANDRA O..DE...
+      | 0xE0 0xA5 0x8E..0x8F    #Mc   [2] DEVANAGARI VOWEL SIGN PRISHTHAMATR...
+      | 0xE0 0xA6 0x82..0x83    #Mc   [2] BENGALI SIGN ANUSVARA..BENGALI SIG...
+      | 0xE0 0xA6 0xBF..0xFF    #Mc   [2] BENGALI VOWEL SIGN I..BENGALI VOWE...
+      | 0xE0 0xA7 0x00..0x80    #
+      | 0xE0 0xA7 0x87..0x88    #Mc   [2] BENGALI VOWEL SIGN E..BENGALI VOWE...
+      | 0xE0 0xA7 0x8B..0x8C    #Mc   [2] BENGALI VOWEL SIGN O..BENGALI VOWE...
+      | 0xE0 0xA8 0x83          #Mc       GURMUKHI SIGN VISARGA
+      | 0xE0 0xA8 0xBE..0xFF    #Mc   [3] GURMUKHI VOWEL SIGN AA..GURMUKHI V...
+      | 0xE0 0xA9 0x00..0x80    #
+      | 0xE0 0xAA 0x83          #Mc       GUJARATI SIGN VISARGA
+      | 0xE0 0xAA 0xBE..0xFF    #Mc   [3] GUJARATI VOWEL SIGN AA..GUJARATI V...
+      | 0xE0 0xAB 0x00..0x80    #
+      | 0xE0 0xAB 0x89          #Mc       GUJARATI VOWEL SIGN CANDRA O
+      | 0xE0 0xAB 0x8B..0x8C    #Mc   [2] GUJARATI VOWEL SIGN O..GUJARATI VO...
+      | 0xE0 0xAC 0x82..0x83    #Mc   [2] ORIYA SIGN ANUSVARA..ORIYA SIGN VI...
+      | 0xE0 0xAD 0x80          #Mc       ORIYA VOWEL SIGN II
+      | 0xE0 0xAD 0x87..0x88    #Mc   [2] ORIYA VOWEL SIGN E..ORIYA VOWEL SI...
+      | 0xE0 0xAD 0x8B..0x8C    #Mc   [2] ORIYA VOWEL SIGN O..ORIYA VOWEL SI...
+      | 0xE0 0xAE 0xBF          #Mc       TAMIL VOWEL SIGN I
+      | 0xE0 0xAF 0x81..0x82    #Mc   [2] TAMIL VOWEL SIGN U..TAMIL VOWEL SI...
+      | 0xE0 0xAF 0x86..0x88    #Mc   [3] TAMIL VOWEL SIGN E..TAMIL VOWEL SI...
+      | 0xE0 0xAF 0x8A..0x8C    #Mc   [3] TAMIL VOWEL SIGN O..TAMIL VOWEL SI...
+      | 0xE0 0xB0 0x81..0x83    #Mc   [3] TELUGU SIGN CANDRABINDU..TELUGU SI...
+      | 0xE0 0xB1 0x81..0x84    #Mc   [4] TELUGU VOWEL SIGN U..TELUGU VOWEL ...
+      | 0xE0 0xB2 0x82..0x83    #Mc   [2] KANNADA SIGN ANUSVARA..KANNADA SIG...
+      | 0xE0 0xB2 0xBE          #Mc       KANNADA VOWEL SIGN AA
+      | 0xE0 0xB3 0x80..0x81    #Mc   [2] KANNADA VOWEL SIGN II..KANNADA VOW...
+      | 0xE0 0xB3 0x83..0x84    #Mc   [2] KANNADA VOWEL SIGN VOCALIC R..KANN...
+      | 0xE0 0xB3 0x87..0x88    #Mc   [2] KANNADA VOWEL SIGN EE..KANNADA VOW...
+      | 0xE0 0xB3 0x8A..0x8B    #Mc   [2] KANNADA VOWEL SIGN O..KANNADA VOWE...
+      | 0xE0 0xB4 0x82..0x83    #Mc   [2] MALAYALAM SIGN ANUSVARA..MALAYALAM...
+      | 0xE0 0xB4 0xBF..0xFF    #Mc   [2] MALAYALAM VOWEL SIGN I..MALAYALAM ...
+      | 0xE0 0xB5 0x00..0x80    #
+      | 0xE0 0xB5 0x86..0x88    #Mc   [3] MALAYALAM VOWEL SIGN E..MALAYALAM ...
+      | 0xE0 0xB5 0x8A..0x8C    #Mc   [3] MALAYALAM VOWEL SIGN O..MALAYALAM ...
+      | 0xE0 0xB6 0x82..0x83    #Mc   [2] SINHALA SIGN ANUSVARAYA..SINHALA S...
+      | 0xE0 0xB7 0x90..0x91    #Mc   [2] SINHALA VOWEL SIGN KETTI AEDA-PILL...
+      | 0xE0 0xB7 0x98..0x9E    #Mc   [7] SINHALA VOWEL SIGN GAETTA-PILLA..S...
+      | 0xE0 0xB7 0xB2..0xB3    #Mc   [2] SINHALA VOWEL SIGN DIGA GAETTA-PIL...
+      | 0xE0 0xB8 0xB3          #Lo       THAI CHARACTER SARA AM
+      | 0xE0 0xBA 0xB3          #Lo       LAO VOWEL SIGN AM
+      | 0xE0 0xBC 0xBE..0xBF    #Mc   [2] TIBETAN SIGN YAR TSHES..TIBETAN SI...
+      | 0xE0 0xBD 0xBF          #Mc       TIBETAN SIGN RNAM BCAD
+      | 0xE1 0x80 0xB1          #Mc       MYANMAR VOWEL SIGN E
+      | 0xE1 0x80 0xBB..0xBC    #Mc   [2] MYANMAR CONSONANT SIGN MEDIAL YA.....
+      | 0xE1 0x81 0x96..0x97    #Mc   [2] MYANMAR VOWEL SIGN VOCALIC R..MYAN...
+      | 0xE1 0x82 0x84          #Mc       MYANMAR VOWEL SIGN SHAN E
+      | 0xE1 0x9E 0xB6          #Mc       KHMER VOWEL SIGN AA
+      | 0xE1 0x9E 0xBE..0xFF    #Mc   [8] KHMER VOWEL SIGN OE..KHMER VOWEL S...
+      | 0xE1 0x9F 0x00..0x85    #
+      | 0xE1 0x9F 0x87..0x88    #Mc   [2] KHMER SIGN REAHMUK..KHMER SIGN YUU...
+      | 0xE1 0xA4 0xA3..0xA6    #Mc   [4] LIMBU VOWEL SIGN EE..LIMBU VOWEL S...
+      | 0xE1 0xA4 0xA9..0xAB    #Mc   [3] LIMBU SUBJOINED LETTER YA..LIMBU S...
+      | 0xE1 0xA4 0xB0..0xB1    #Mc   [2] LIMBU SMALL LETTER KA..LIMBU SMALL...
+      | 0xE1 0xA4 0xB3..0xB8    #Mc   [6] LIMBU SMALL LETTER TA..LIMBU SMALL...
+      | 0xE1 0xA8 0x99..0x9A    #Mc   [2] BUGINESE VOWEL SIGN E..BUGINESE VO...
+      | 0xE1 0xA9 0x95          #Mc       TAI THAM CONSONANT SIGN MEDIAL RA
+      | 0xE1 0xA9 0x97          #Mc       TAI THAM CONSONANT SIGN LA TANG LAI
+      | 0xE1 0xA9 0xAD..0xB2    #Mc   [6] TAI THAM VOWEL SIGN OY..TAI THAM V...
+      | 0xE1 0xAC 0x84          #Mc       BALINESE SIGN BISAH
+      | 0xE1 0xAC 0xB5          #Mc       BALINESE VOWEL SIGN TEDUNG
+      | 0xE1 0xAC 0xBB          #Mc       BALINESE VOWEL SIGN RA REPA TEDUNG
+      | 0xE1 0xAC 0xBD..0xFF    #Mc   [5] BALINESE VOWEL SIGN LA LENGA TEDUN...
+      | 0xE1 0xAD 0x00..0x81    #
+      | 0xE1 0xAD 0x83..0x84    #Mc   [2] BALINESE VOWEL SIGN PEPET TEDUNG.....
+      | 0xE1 0xAE 0x82          #Mc       SUNDANESE SIGN PANGWISAD
+      | 0xE1 0xAE 0xA1          #Mc       SUNDANESE CONSONANT SIGN PAMINGKAL
+      | 0xE1 0xAE 0xA6..0xA7    #Mc   [2] SUNDANESE VOWEL SIGN PANAELAENG..S...
+      | 0xE1 0xAE 0xAA          #Mc       SUNDANESE SIGN PAMAAEH
+      | 0xE1 0xAF 0xA7          #Mc       BATAK VOWEL SIGN E
+      | 0xE1 0xAF 0xAA..0xAC    #Mc   [3] BATAK VOWEL SIGN I..BATAK VOWEL SI...
+      | 0xE1 0xAF 0xAE          #Mc       BATAK VOWEL SIGN U
+      | 0xE1 0xAF 0xB2..0xB3    #Mc   [2] BATAK PANGOLAT..BATAK PANONGONAN
+      | 0xE1 0xB0 0xA4..0xAB    #Mc   [8] LEPCHA SUBJOINED LETTER YA..LEPCHA...
+      | 0xE1 0xB0 0xB4..0xB5    #Mc   [2] LEPCHA CONSONANT SIGN NYIN-DO..LEP...
+      | 0xE1 0xB3 0xA1          #Mc       VEDIC TONE ATHARVAVEDIC INDEPENDEN...
+      | 0xE1 0xB3 0xB2..0xB3    #Mc   [2] VEDIC SIGN ARDHAVISARGA..VEDIC SIG...
+      | 0xEA 0xA0 0xA3..0xA4    #Mc   [2] SYLOTI NAGRI VOWEL SIGN A..SYLOTI ...
+      | 0xEA 0xA0 0xA7          #Mc       SYLOTI NAGRI VOWEL SIGN OO
+      | 0xEA 0xA2 0x80..0x81    #Mc   [2] SAURASHTRA SIGN ANUSVARA..SAURASHT...
+      | 0xEA 0xA2 0xB4..0xFF    #Mc  [16] SAURASHTRA CONSONANT SIGN HAARU..S...
+      | 0xEA 0xA3 0x00..0x83    #
+      | 0xEA 0xA5 0x92..0x93    #Mc   [2] REJANG CONSONANT SIGN H..REJANG VI...
+      | 0xEA 0xA6 0x83          #Mc       JAVANESE SIGN WIGNYAN
+      | 0xEA 0xA6 0xB4..0xB5    #Mc   [2] JAVANESE VOWEL SIGN TARUNG..JAVANE...
+      | 0xEA 0xA6 0xBA..0xBB    #Mc   [2] JAVANESE VOWEL SIGN TALING..JAVANE...
+      | 0xEA 0xA6 0xBD..0xFF    #Mc   [4] JAVANESE CONSONANT SIGN KERET..JAV...
+      | 0xEA 0xA7 0x00..0x80    #
+      | 0xEA 0xA8 0xAF..0xB0    #Mc   [2] CHAM VOWEL SIGN O..CHAM VOWEL SIGN AI
+      | 0xEA 0xA8 0xB3..0xB4    #Mc   [2] CHAM CONSONANT SIGN YA..CHAM CONSO...
+      | 0xEA 0xA9 0x8D          #Mc       CHAM CONSONANT SIGN FINAL H
+      | 0xEA 0xAB 0xAB          #Mc       MEETEI MAYEK VOWEL SIGN II
+      | 0xEA 0xAB 0xAE..0xAF    #Mc   [2] MEETEI MAYEK VOWEL SIGN AU..MEETEI...
+      | 0xEA 0xAB 0xB5          #Mc       MEETEI MAYEK VOWEL SIGN VISARGA
+      | 0xEA 0xAF 0xA3..0xA4    #Mc   [2] MEETEI MAYEK VOWEL SIGN ONAP..MEET...
+      | 0xEA 0xAF 0xA6..0xA7    #Mc   [2] MEETEI MAYEK VOWEL SIGN YENAP..MEE...
+      | 0xEA 0xAF 0xA9..0xAA    #Mc   [2] MEETEI MAYEK VOWEL SIGN CHEINAP..M...
+      | 0xEA 0xAF 0xAC          #Mc       MEETEI MAYEK LUM IYEK
+      | 0xF0 0x91 0x80 0x80     #Mc       BRAHMI SIGN CANDRABINDU
+      | 0xF0 0x91 0x80 0x82     #Mc       BRAHMI SIGN VISARGA
+      | 0xF0 0x91 0x82 0x82     #Mc       KAITHI SIGN VISARGA
+      | 0xF0 0x91 0x82 0xB0..0xB2  #Mc   [3] KAITHI VOWEL SIGN AA..KAITHI VO...
+      | 0xF0 0x91 0x82 0xB7..0xB8  #Mc   [2] KAITHI VOWEL SIGN O..KAITHI VOW...
+      | 0xF0 0x91 0x84 0xAC     #Mc       CHAKMA VOWEL SIGN E
+      | 0xF0 0x91 0x86 0x82     #Mc       SHARADA SIGN VISARGA
+      | 0xF0 0x91 0x86 0xB3..0xB5  #Mc   [3] SHARADA VOWEL SIGN AA..SHARADA ...
+      | 0xF0 0x91 0x86 0xBF..0xFF  #Mc   [2] SHARADA VOWEL SIGN AU..SHARADA ...
+      | 0xF0 0x91 0x87 0x00..0x80  #
+      | 0xF0 0x91 0x88 0xAC..0xAE  #Mc   [3] KHOJKI VOWEL SIGN AA..KHOJKI VO...
+      | 0xF0 0x91 0x88 0xB2..0xB3  #Mc   [2] KHOJKI VOWEL SIGN O..KHOJKI VOW...
+      | 0xF0 0x91 0x88 0xB5     #Mc       KHOJKI SIGN VIRAMA
+      | 0xF0 0x91 0x8B 0xA0..0xA2  #Mc   [3] KHUDAWADI VOWEL SIGN AA..KHUDAW...
+      | 0xF0 0x91 0x8C 0x82..0x83  #Mc   [2] GRANTHA SIGN ANUSVARA..GRANTHA ...
+      | 0xF0 0x91 0x8C 0xBF     #Mc       GRANTHA VOWEL SIGN I
+      | 0xF0 0x91 0x8D 0x81..0x84  #Mc   [4] GRANTHA VOWEL SIGN U..GRANTHA V...
+      | 0xF0 0x91 0x8D 0x87..0x88  #Mc   [2] GRANTHA VOWEL SIGN EE..GRANTHA ...
+      | 0xF0 0x91 0x8D 0x8B..0x8D  #Mc   [3] GRANTHA VOWEL SIGN OO..GRANTHA ...
+      | 0xF0 0x91 0x8D 0xA2..0xA3  #Mc   [2] GRANTHA VOWEL SIGN VOCALIC L..G...
+      | 0xF0 0x91 0x90 0xB5..0xB7  #Mc   [3] NEWA VOWEL SIGN AA..NEWA VOWEL ...
+      | 0xF0 0x91 0x91 0x80..0x81  #Mc   [2] NEWA VOWEL SIGN O..NEWA VOWEL S...
+      | 0xF0 0x91 0x91 0x85     #Mc       NEWA SIGN VISARGA
+      | 0xF0 0x91 0x92 0xB1..0xB2  #Mc   [2] TIRHUTA VOWEL SIGN I..TIRHUTA V...
+      | 0xF0 0x91 0x92 0xB9     #Mc       TIRHUTA VOWEL SIGN E
+      | 0xF0 0x91 0x92 0xBB..0xBC  #Mc   [2] TIRHUTA VOWEL SIGN AI..TIRHUTA ...
+      | 0xF0 0x91 0x92 0xBE     #Mc       TIRHUTA VOWEL SIGN AU
+      | 0xF0 0x91 0x93 0x81     #Mc       TIRHUTA SIGN VISARGA
+      | 0xF0 0x91 0x96 0xB0..0xB1  #Mc   [2] SIDDHAM VOWEL SIGN I..SIDDHAM V...
+      | 0xF0 0x91 0x96 0xB8..0xBB  #Mc   [4] SIDDHAM VOWEL SIGN E..SIDDHAM V...
+      | 0xF0 0x91 0x96 0xBE     #Mc       SIDDHAM SIGN VISARGA
+      | 0xF0 0x91 0x98 0xB0..0xB2  #Mc   [3] MODI VOWEL SIGN AA..MODI VOWEL ...
+      | 0xF0 0x91 0x98 0xBB..0xBC  #Mc   [2] MODI VOWEL SIGN O..MODI VOWEL S...
+      | 0xF0 0x91 0x98 0xBE     #Mc       MODI SIGN VISARGA
+      | 0xF0 0x91 0x9A 0xAC     #Mc       TAKRI SIGN VISARGA
+      | 0xF0 0x91 0x9A 0xAE..0xAF  #Mc   [2] TAKRI VOWEL SIGN I..TAKRI VOWEL...
+      | 0xF0 0x91 0x9A 0xB6     #Mc       TAKRI SIGN VIRAMA
+      | 0xF0 0x91 0x9C 0xA0..0xA1  #Mc   [2] AHOM VOWEL SIGN A..AHOM VOWEL S...
+      | 0xF0 0x91 0x9C 0xA6     #Mc       AHOM VOWEL SIGN E
+      | 0xF0 0x91 0xB0 0xAF     #Mc       BHAIKSUKI VOWEL SIGN AA
+      | 0xF0 0x91 0xB0 0xBE     #Mc       BHAIKSUKI SIGN VISARGA
+      | 0xF0 0x91 0xB2 0xA9     #Mc       MARCHEN SUBJOINED LETTER YA
+      | 0xF0 0x91 0xB2 0xB1     #Mc       MARCHEN VOWEL SIGN I
+      | 0xF0 0x91 0xB2 0xB4     #Mc       MARCHEN VOWEL SIGN O
+      | 0xF0 0x96 0xBD 0x91..0xBE  #Mc  [46] MIAO SIGN ASPIRATION..MIAO VOWE...
+      | 0xF0 0x9D 0x85 0xA6     #Mc       MUSICAL SYMBOL COMBINING SPRECHGES...
+      | 0xF0 0x9D 0x85 0xAD     #Mc       MUSICAL SYMBOL COMBINING AUGMENTAT...
+      ;
+
+    L = 
+        0xE1 0x84 0x80..0xFF    #Lo  [96] HANGUL CHOSEONG KIYEOK..HANGUL CHO...
+      | 0xE1 0x85 0x00..0x9F    #
+      | 0xEA 0xA5 0xA0..0xBC    #Lo  [29] HANGUL CHOSEONG TIKEUT-MIEUM..HANG...
+      ;
+
+    V = 
+        0xE1 0x85 0xA0..0xFF    #Lo  [72] HANGUL JUNGSEONG FILLER..HANGUL JU...
+      | 0xE1 0x86 0x00..0xA7    #
+      | 0xED 0x9E 0xB0..0xFF    #Lo  [23] HANGUL JUNGSEONG O-YEO..HANGUL JUN...
+      | 0xED 0x9F 0x00..0x86    #
+      ;
+
+    T = 
+        0xE1 0x86 0xA8..0xFF    #Lo  [88] HANGUL JONGSEONG KIYEOK..HANGUL JO...
+      | 0xE1 0x87 0x00..0xBF    #
+      | 0xED 0x9F 0x8B..0xBB    #Lo  [49] HANGUL JONGSEONG NIEUN-RIEUL..HANG...
+      ;
+
+    LV = 
+        0xEA 0xB0 0x80          #Lo       HANGUL SYLLABLE GA
+      | 0xEA 0xB0 0x9C          #Lo       HANGUL SYLLABLE GAE
+      | 0xEA 0xB0 0xB8          #Lo       HANGUL SYLLABLE GYA
+      | 0xEA 0xB1 0x94          #Lo       HANGUL SYLLABLE GYAE
+      | 0xEA 0xB1 0xB0          #Lo       HANGUL SYLLABLE GEO
+      | 0xEA 0xB2 0x8C          #Lo       HANGUL SYLLABLE GE
+      | 0xEA 0xB2 0xA8          #Lo       HANGUL SYLLABLE GYEO
+      | 0xEA 0xB3 0x84          #Lo       HANGUL SYLLABLE GYE
+      | 0xEA 0xB3 0xA0          #Lo       HANGUL SYLLABLE GO
+      | 0xEA 0xB3 0xBC          #Lo       HANGUL SYLLABLE GWA
+      | 0xEA 0xB4 0x98          #Lo       HANGUL SYLLABLE GWAE
+      | 0xEA 0xB4 0xB4          #Lo       HANGUL SYLLABLE GOE
+      | 0xEA 0xB5 0x90          #Lo       HANGUL SYLLABLE GYO
+      | 0xEA 0xB5 0xAC          #Lo       HANGUL SYLLABLE GU
+      | 0xEA 0xB6 0x88          #Lo       HANGUL SYLLABLE GWEO
+      | 0xEA 0xB6 0xA4          #Lo       HANGUL SYLLABLE GWE
+      | 0xEA 0xB7 0x80          #Lo       HANGUL SYLLABLE GWI
+      | 0xEA 0xB7 0x9C          #Lo       HANGUL SYLLABLE GYU
+      | 0xEA 0xB7 0xB8          #Lo       HANGUL SYLLABLE GEU
+      | 0xEA 0xB8 0x94          #Lo       HANGUL SYLLABLE GYI
+      | 0xEA 0xB8 0xB0          #Lo       HANGUL SYLLABLE GI
+      | 0xEA 0xB9 0x8C          #Lo       HANGUL SYLLABLE GGA
+      | 0xEA 0xB9 0xA8          #Lo       HANGUL SYLLABLE GGAE
+      | 0xEA 0xBA 0x84          #Lo       HANGUL SYLLABLE GGYA
+      | 0xEA 0xBA 0xA0          #Lo       HANGUL SYLLABLE GGYAE
+      | 0xEA 0xBA 0xBC          #Lo       HANGUL SYLLABLE GGEO
+      | 0xEA 0xBB 0x98          #Lo       HANGUL SYLLABLE GGE
+      | 0xEA 0xBB 0xB4          #Lo       HANGUL SYLLABLE GGYEO
+      | 0xEA 0xBC 0x90          #Lo       HANGUL SYLLABLE GGYE
+      | 0xEA 0xBC 0xAC          #Lo       HANGUL SYLLABLE GGO
+      | 0xEA 0xBD 0x88          #Lo       HANGUL SYLLABLE GGWA
+      | 0xEA 0xBD 0xA4          #Lo       HANGUL SYLLABLE GGWAE
+      | 0xEA 0xBE 0x80          #Lo       HANGUL SYLLABLE GGOE
+      | 0xEA 0xBE 0x9C          #Lo       HANGUL SYLLABLE GGYO
+      | 0xEA 0xBE 0xB8          #Lo       HANGUL SYLLABLE GGU
+      | 0xEA 0xBF 0x94          #Lo       HANGUL SYLLABLE GGWEO
+      | 0xEA 0xBF 0xB0          #Lo       HANGUL SYLLABLE GGWE
+      | 0xEB 0x80 0x8C          #Lo       HANGUL SYLLABLE GGWI
+      | 0xEB 0x80 0xA8          #Lo       HANGUL SYLLABLE GGYU
+      | 0xEB 0x81 0x84          #Lo       HANGUL SYLLABLE GGEU
+      | 0xEB 0x81 0xA0          #Lo       HANGUL SYLLABLE GGYI
+      | 0xEB 0x81 0xBC          #Lo       HANGUL SYLLABLE GGI
+      | 0xEB 0x82 0x98          #Lo       HANGUL SYLLABLE NA
+      | 0xEB 0x82 0xB4          #Lo       HANGUL SYLLABLE NAE
+      | 0xEB 0x83 0x90          #Lo       HANGUL SYLLABLE NYA
+      | 0xEB 0x83 0xAC          #Lo       HANGUL SYLLABLE NYAE
+      | 0xEB 0x84 0x88          #Lo       HANGUL SYLLABLE NEO
+      | 0xEB 0x84 0xA4          #Lo       HANGUL SYLLABLE NE
+      | 0xEB 0x85 0x80          #Lo       HANGUL SYLLABLE NYEO
+      | 0xEB 0x85 0x9C          #Lo       HANGUL SYLLABLE NYE
+      | 0xEB 0x85 0xB8          #Lo       HANGUL SYLLABLE NO
+      | 0xEB 0x86 0x94          #Lo       HANGUL SYLLABLE NWA
+      | 0xEB 0x86 0xB0          #Lo       HANGUL SYLLABLE NWAE
+      | 0xEB 0x87 0x8C          #Lo       HANGUL SYLLABLE NOE
+      | 0xEB 0x87 0xA8          #Lo       HANGUL SYLLABLE NYO
+      | 0xEB 0x88 0x84          #Lo       HANGUL SYLLABLE NU
+      | 0xEB 0x88 0xA0          #Lo       HANGUL SYLLABLE NWEO
+      | 0xEB 0x88 0xBC          #Lo       HANGUL SYLLABLE NWE
+      | 0xEB 0x89 0x98          #Lo       HANGUL SYLLABLE NWI
+      | 0xEB 0x89 0xB4          #Lo       HANGUL SYLLABLE NYU
+      | 0xEB 0x8A 0x90          #Lo       HANGUL SYLLABLE NEU
+      | 0xEB 0x8A 0xAC          #Lo       HANGUL SYLLABLE NYI
+      | 0xEB 0x8B 0x88          #Lo       HANGUL SYLLABLE NI
+      | 0xEB 0x8B 0xA4          #Lo       HANGUL SYLLABLE DA
+      | 0xEB 0x8C 0x80          #Lo       HANGUL SYLLABLE DAE
+      | 0xEB 0x8C 0x9C          #Lo       HANGUL SYLLABLE DYA
+      | 0xEB 0x8C 0xB8          #Lo       HANGUL SYLLABLE DYAE
+      | 0xEB 0x8D 0x94          #Lo       HANGUL SYLLABLE DEO
+      | 0xEB 0x8D 0xB0          #Lo       HANGUL SYLLABLE DE
+      | 0xEB 0x8E 0x8C          #Lo       HANGUL SYLLABLE DYEO
+      | 0xEB 0x8E 0xA8          #Lo       HANGUL SYLLABLE DYE
+      | 0xEB 0x8F 0x84          #Lo       HANGUL SYLLABLE DO
+      | 0xEB 0x8F 0xA0          #Lo       HANGUL SYLLABLE DWA
+      | 0xEB 0x8F 0xBC          #Lo       HANGUL SYLLABLE DWAE
+      | 0xEB 0x90 0x98          #Lo       HANGUL SYLLABLE DOE
+      | 0xEB 0x90 0xB4          #Lo       HANGUL SYLLABLE DYO
+      | 0xEB 0x91 0x90          #Lo       HANGUL SYLLABLE DU
+      | 0xEB 0x91 0xAC          #Lo       HANGUL SYLLABLE DWEO
+      | 0xEB 0x92 0x88          #Lo       HANGUL SYLLABLE DWE
+      | 0xEB 0x92 0xA4          #Lo       HANGUL SYLLABLE DWI
+      | 0xEB 0x93 0x80          #Lo       HANGUL SYLLABLE DYU
+      | 0xEB 0x93 0x9C          #Lo       HANGUL SYLLABLE DEU
+      | 0xEB 0x93 0xB8          #Lo       HANGUL SYLLABLE DYI
+      | 0xEB 0x94 0x94          #Lo       HANGUL SYLLABLE DI
+      | 0xEB 0x94 0xB0          #Lo       HANGUL SYLLABLE DDA
+      | 0xEB 0x95 0x8C          #Lo       HANGUL SYLLABLE DDAE
+      | 0xEB 0x95 0xA8          #Lo       HANGUL SYLLABLE DDYA
+      | 0xEB 0x96 0x84          #Lo       HANGUL SYLLABLE DDYAE
+      | 0xEB 0x96 0xA0          #Lo       HANGUL SYLLABLE DDEO
+      | 0xEB 0x96 0xBC          #Lo       HANGUL SYLLABLE DDE
+      | 0xEB 0x97 0x98          #Lo       HANGUL SYLLABLE DDYEO
+      | 0xEB 0x97 0xB4          #Lo       HANGUL SYLLABLE DDYE
+      | 0xEB 0x98 0x90          #Lo       HANGUL SYLLABLE DDO
+      | 0xEB 0x98 0xAC          #Lo       HANGUL SYLLABLE DDWA
+      | 0xEB 0x99 0x88          #Lo       HANGUL SYLLABLE DDWAE
+      | 0xEB 0x99 0xA4          #Lo       HANGUL SYLLABLE DDOE
+      | 0xEB 0x9A 0x80          #Lo       HANGUL SYLLABLE DDYO
+      | 0xEB 0x9A 0x9C          #Lo       HANGUL SYLLABLE DDU
+      | 0xEB 0x9A 0xB8          #Lo       HANGUL SYLLABLE DDWEO
+      | 0xEB 0x9B 0x94          #Lo       HANGUL SYLLABLE DDWE
+      | 0xEB 0x9B 0xB0          #Lo       HANGUL SYLLABLE DDWI
+      | 0xEB 0x9C 0x8C          #Lo       HANGUL SYLLABLE DDYU
+      | 0xEB 0x9C 0xA8          #Lo       HANGUL SYLLABLE DDEU
+      | 0xEB 0x9D 0x84          #Lo       HANGUL SYLLABLE DDYI
+      | 0xEB 0x9D 0xA0          #Lo       HANGUL SYLLABLE DDI
+      | 0xEB 0x9D 0xBC          #Lo       HANGUL SYLLABLE RA
+      | 0xEB 0x9E 0x98          #Lo       HANGUL SYLLABLE RAE
+      | 0xEB 0x9E 0xB4          #Lo       HANGUL SYLLABLE RYA
+      | 0xEB 0x9F 0x90          #Lo       HANGUL SYLLABLE RYAE
+      | 0xEB 0x9F 0xAC          #Lo       HANGUL SYLLABLE REO
+      | 0xEB 0xA0 0x88          #Lo       HANGUL SYLLABLE RE
+      | 0xEB 0xA0 0xA4          #Lo       HANGUL SYLLABLE RYEO
+      | 0xEB 0xA1 0x80          #Lo       HANGUL SYLLABLE RYE
+      | 0xEB 0xA1 0x9C          #Lo       HANGUL SYLLABLE RO
+      | 0xEB 0xA1 0xB8          #Lo       HANGUL SYLLABLE RWA
+      | 0xEB 0xA2 0x94          #Lo       HANGUL SYLLABLE RWAE
+      | 0xEB 0xA2 0xB0          #Lo       HANGUL SYLLABLE ROE
+      | 0xEB 0xA3 0x8C          #Lo       HANGUL SYLLABLE RYO
+      | 0xEB 0xA3 0xA8          #Lo       HANGUL SYLLABLE RU
+      | 0xEB 0xA4 0x84          #Lo       HANGUL SYLLABLE RWEO
+      | 0xEB 0xA4 0xA0          #Lo       HANGUL SYLLABLE RWE
+      | 0xEB 0xA4 0xBC          #Lo       HANGUL SYLLABLE RWI
+      | 0xEB 0xA5 0x98          #Lo       HANGUL SYLLABLE RYU
+      | 0xEB 0xA5 0xB4          #Lo       HANGUL SYLLABLE REU
+      | 0xEB 0xA6 0x90          #Lo       HANGUL SYLLABLE RYI
+      | 0xEB 0xA6 0xAC          #Lo       HANGUL SYLLABLE RI
+      | 0xEB 0xA7 0x88          #Lo       HANGUL SYLLABLE MA
+      | 0xEB 0xA7 0xA4          #Lo       HANGUL SYLLABLE MAE
+      | 0xEB 0xA8 0x80          #Lo       HANGUL SYLLABLE MYA
+      | 0xEB 0xA8 0x9C          #Lo       HANGUL SYLLABLE MYAE
+      | 0xEB 0xA8 0xB8          #Lo       HANGUL SYLLABLE MEO
+      | 0xEB 0xA9 0x94          #Lo       HANGUL SYLLABLE ME
+      | 0xEB 0xA9 0xB0          #Lo       HANGUL SYLLABLE MYEO
+      | 0xEB 0xAA 0x8C          #Lo       HANGUL SYLLABLE MYE
+      | 0xEB 0xAA 0xA8          #Lo       HANGUL SYLLABLE MO
+      | 0xEB 0xAB 0x84          #Lo       HANGUL SYLLABLE MWA
+      | 0xEB 0xAB 0xA0          #Lo       HANGUL SYLLABLE MWAE
+      | 0xEB 0xAB 0xBC          #Lo       HANGUL SYLLABLE MOE
+      | 0xEB 0xAC 0x98          #Lo       HANGUL SYLLABLE MYO
+      | 0xEB 0xAC 0xB4          #Lo       HANGUL SYLLABLE MU
+      | 0xEB 0xAD 0x90          #Lo       HANGUL SYLLABLE MWEO
+      | 0xEB 0xAD 0xAC          #Lo       HANGUL SYLLABLE MWE
+      | 0xEB 0xAE 0x88          #Lo       HANGUL SYLLABLE MWI
+      | 0xEB 0xAE 0xA4          #Lo       HANGUL SYLLABLE MYU
+      | 0xEB 0xAF 0x80          #Lo       HANGUL SYLLABLE MEU
+      | 0xEB 0xAF 0x9C          #Lo       HANGUL SYLLABLE MYI
+      | 0xEB 0xAF 0xB8          #Lo       HANGUL SYLLABLE MI
+      | 0xEB 0xB0 0x94          #Lo       HANGUL SYLLABLE BA
+      | 0xEB 0xB0 0xB0          #Lo       HANGUL SYLLABLE BAE
+      | 0xEB 0xB1 0x8C          #Lo       HANGUL SYLLABLE BYA
+      | 0xEB 0xB1 0xA8          #Lo       HANGUL SYLLABLE BYAE
+      | 0xEB 0xB2 0x84          #Lo       HANGUL SYLLABLE BEO
+      | 0xEB 0xB2 0xA0          #Lo       HANGUL SYLLABLE BE
+      | 0xEB 0xB2 0xBC          #Lo       HANGUL SYLLABLE BYEO
+      | 0xEB 0xB3 0x98          #Lo       HANGUL SYLLABLE BYE
+      | 0xEB 0xB3 0xB4          #Lo       HANGUL SYLLABLE BO
+      | 0xEB 0xB4 0x90          #Lo       HANGUL SYLLABLE BWA
+      | 0xEB 0xB4 0xAC          #Lo       HANGUL SYLLABLE BWAE
+      | 0xEB 0xB5 0x88          #Lo       HANGUL SYLLABLE BOE
+      | 0xEB 0xB5 0xA4          #Lo       HANGUL SYLLABLE BYO
+      | 0xEB 0xB6 0x80          #Lo       HANGUL SYLLABLE BU
+      | 0xEB 0xB6 0x9C          #Lo       HANGUL SYLLABLE BWEO
+      | 0xEB 0xB6 0xB8          #Lo       HANGUL SYLLABLE BWE
+      | 0xEB 0xB7 0x94          #Lo       HANGUL SYLLABLE BWI
+      | 0xEB 0xB7 0xB0          #Lo       HANGUL SYLLABLE BYU
+      | 0xEB 0xB8 0x8C          #Lo       HANGUL SYLLABLE BEU
+      | 0xEB 0xB8 0xA8          #Lo       HANGUL SYLLABLE BYI
+      | 0xEB 0xB9 0x84          #Lo       HANGUL SYLLABLE BI
+      | 0xEB 0xB9 0xA0          #Lo       HANGUL SYLLABLE BBA
+      | 0xEB 0xB9 0xBC          #Lo       HANGUL SYLLABLE BBAE
+      | 0xEB 0xBA 0x98          #Lo       HANGUL SYLLABLE BBYA
+      | 0xEB 0xBA 0xB4          #Lo       HANGUL SYLLABLE BBYAE
+      | 0xEB 0xBB 0x90          #Lo       HANGUL SYLLABLE BBEO
+      | 0xEB 0xBB 0xAC          #Lo       HANGUL SYLLABLE BBE
+      | 0xEB 0xBC 0x88          #Lo       HANGUL SYLLABLE BBYEO
+      | 0xEB 0xBC 0xA4          #Lo       HANGUL SYLLABLE BBYE
+      | 0xEB 0xBD 0x80          #Lo       HANGUL SYLLABLE BBO
+      | 0xEB 0xBD 0x9C          #Lo       HANGUL SYLLABLE BBWA
+      | 0xEB 0xBD 0xB8          #Lo       HANGUL SYLLABLE BBWAE
+      | 0xEB 0xBE 0x94          #Lo       HANGUL SYLLABLE BBOE
+      | 0xEB 0xBE 0xB0          #Lo       HANGUL SYLLABLE BBYO
+      | 0xEB 0xBF 0x8C          #Lo       HANGUL SYLLABLE BBU
+      | 0xEB 0xBF 0xA8          #Lo       HANGUL SYLLABLE BBWEO
+      | 0xEC 0x80 0x84          #Lo       HANGUL SYLLABLE BBWE
+      | 0xEC 0x80 0xA0          #Lo       HANGUL SYLLABLE BBWI
+      | 0xEC 0x80 0xBC          #Lo       HANGUL SYLLABLE BBYU
+      | 0xEC 0x81 0x98          #Lo       HANGUL SYLLABLE BBEU
+      | 0xEC 0x81 0xB4          #Lo       HANGUL SYLLABLE BBYI
+      | 0xEC 0x82 0x90          #Lo       HANGUL SYLLABLE BBI
+      | 0xEC 0x82 0xAC          #Lo       HANGUL SYLLABLE SA
+      | 0xEC 0x83 0x88          #Lo       HANGUL SYLLABLE SAE
+      | 0xEC 0x83 0xA4          #Lo       HANGUL SYLLABLE SYA
+      | 0xEC 0x84 0x80          #Lo       HANGUL SYLLABLE SYAE
+      | 0xEC 0x84 0x9C          #Lo       HANGUL SYLLABLE SEO
+      | 0xEC 0x84 0xB8          #Lo       HANGUL SYLLABLE SE
+      | 0xEC 0x85 0x94          #Lo       HANGUL SYLLABLE SYEO
+      | 0xEC 0x85 0xB0          #Lo       HANGUL SYLLABLE SYE
+      | 0xEC 0x86 0x8C          #Lo       HANGUL SYLLABLE SO
+      | 0xEC 0x86 0xA8          #Lo       HANGUL SYLLABLE SWA
+      | 0xEC 0x87 0x84          #Lo       HANGUL SYLLABLE SWAE
+      | 0xEC 0x87 0xA0          #Lo       HANGUL SYLLABLE SOE
+      | 0xEC 0x87 0xBC          #Lo       HANGUL SYLLABLE SYO
+      | 0xEC 0x88 0x98          #Lo       HANGUL SYLLABLE SU
+      | 0xEC 0x88 0xB4          #Lo       HANGUL SYLLABLE SWEO
+      | 0xEC 0x89 0x90          #Lo       HANGUL SYLLABLE SWE
+      | 0xEC 0x89 0xAC          #Lo       HANGUL SYLLABLE SWI
+      | 0xEC 0x8A 0x88          #Lo       HANGUL SYLLABLE SYU
+      | 0xEC 0x8A 0xA4          #Lo       HANGUL SYLLABLE SEU
+      | 0xEC 0x8B 0x80          #Lo       HANGUL SYLLABLE SYI
+      | 0xEC 0x8B 0x9C          #Lo       HANGUL SYLLABLE SI
+      | 0xEC 0x8B 0xB8          #Lo       HANGUL SYLLABLE SSA
+      | 0xEC 0x8C 0x94          #Lo       HANGUL SYLLABLE SSAE
+      | 0xEC 0x8C 0xB0          #Lo       HANGUL SYLLABLE SSYA
+      | 0xEC 0x8D 0x8C          #Lo       HANGUL SYLLABLE SSYAE
+      | 0xEC 0x8D 0xA8          #Lo       HANGUL SYLLABLE SSEO
+      | 0xEC 0x8E 0x84          #Lo       HANGUL SYLLABLE SSE
+      | 0xEC 0x8E 0xA0          #Lo       HANGUL SYLLABLE SSYEO
+      | 0xEC 0x8E 0xBC          #Lo       HANGUL SYLLABLE SSYE
+      | 0xEC 0x8F 0x98          #Lo       HANGUL SYLLABLE SSO
+      | 0xEC 0x8F 0xB4          #Lo       HANGUL SYLLABLE SSWA
+      | 0xEC 0x90 0x90          #Lo       HANGUL SYLLABLE SSWAE
+      | 0xEC 0x90 0xAC          #Lo       HANGUL SYLLABLE SSOE
+      | 0xEC 0x91 0x88          #Lo       HANGUL SYLLABLE SSYO
+      | 0xEC 0x91 0xA4          #Lo       HANGUL SYLLABLE SSU
+      | 0xEC 0x92 0x80          #Lo       HANGUL SYLLABLE SSWEO
+      | 0xEC 0x92 0x9C          #Lo       HANGUL SYLLABLE SSWE
+      | 0xEC 0x92 0xB8          #Lo       HANGUL SYLLABLE SSWI
+      | 0xEC 0x93 0x94          #Lo       HANGUL SYLLABLE SSYU
+      | 0xEC 0x93 0xB0          #Lo       HANGUL SYLLABLE SSEU
+      | 0xEC 0x94 0x8C          #Lo       HANGUL SYLLABLE SSYI
+      | 0xEC 0x94 0xA8          #Lo       HANGUL SYLLABLE SSI
+      | 0xEC 0x95 0x84          #Lo       HANGUL SYLLABLE A
+      | 0xEC 0x95 0xA0          #Lo       HANGUL SYLLABLE AE
+      | 0xEC 0x95 0xBC          #Lo       HANGUL SYLLABLE YA
+      | 0xEC 0x96 0x98          #Lo       HANGUL SYLLABLE YAE
+      | 0xEC 0x96 0xB4          #Lo       HANGUL SYLLABLE EO
+      | 0xEC 0x97 0x90          #Lo       HANGUL SYLLABLE E
+      | 0xEC 0x97 0xAC          #Lo       HANGUL SYLLABLE YEO
+      | 0xEC 0x98 0x88          #Lo       HANGUL SYLLABLE YE
+      | 0xEC 0x98 0xA4          #Lo       HANGUL SYLLABLE O
+      | 0xEC 0x99 0x80          #Lo       HANGUL SYLLABLE WA
+      | 0xEC 0x99 0x9C          #Lo       HANGUL SYLLABLE WAE
+      | 0xEC 0x99 0xB8          #Lo       HANGUL SYLLABLE OE
+      | 0xEC 0x9A 0x94          #Lo       HANGUL SYLLABLE YO
+      | 0xEC 0x9A 0xB0          #Lo       HANGUL SYLLABLE U
+      | 0xEC 0x9B 0x8C          #Lo       HANGUL SYLLABLE WEO
+      | 0xEC 0x9B 0xA8          #Lo       HANGUL SYLLABLE WE
+      | 0xEC 0x9C 0x84          #Lo       HANGUL SYLLABLE WI
+      | 0xEC 0x9C 0xA0          #Lo       HANGUL SYLLABLE YU
+      | 0xEC 0x9C 0xBC          #Lo       HANGUL SYLLABLE EU
+      | 0xEC 0x9D 0x98          #Lo       HANGUL SYLLABLE YI
+      | 0xEC 0x9D 0xB4          #Lo       HANGUL SYLLABLE I
+      | 0xEC 0x9E 0x90          #Lo       HANGUL SYLLABLE JA
+      | 0xEC 0x9E 0xAC          #Lo       HANGUL SYLLABLE JAE
+      | 0xEC 0x9F 0x88          #Lo       HANGUL SYLLABLE JYA
+      | 0xEC 0x9F 0xA4          #Lo       HANGUL SYLLABLE JYAE
+      | 0xEC 0xA0 0x80          #Lo       HANGUL SYLLABLE JEO
+      | 0xEC 0xA0 0x9C          #Lo       HANGUL SYLLABLE JE
+      | 0xEC 0xA0 0xB8          #Lo       HANGUL SYLLABLE JYEO
+      | 0xEC 0xA1 0x94          #Lo       HANGUL SYLLABLE JYE
+      | 0xEC 0xA1 0xB0          #Lo       HANGUL SYLLABLE JO
+      | 0xEC 0xA2 0x8C          #Lo       HANGUL SYLLABLE JWA
+      | 0xEC 0xA2 0xA8          #Lo       HANGUL SYLLABLE JWAE
+      | 0xEC 0xA3 0x84          #Lo       HANGUL SYLLABLE JOE
+      | 0xEC 0xA3 0xA0          #Lo       HANGUL SYLLABLE JYO
+      | 0xEC 0xA3 0xBC          #Lo       HANGUL SYLLABLE JU
+      | 0xEC 0xA4 0x98          #Lo       HANGUL SYLLABLE JWEO
+      | 0xEC 0xA4 0xB4          #Lo       HANGUL SYLLABLE JWE
+      | 0xEC 0xA5 0x90          #Lo       HANGUL SYLLABLE JWI
+      | 0xEC 0xA5 0xAC          #Lo       HANGUL SYLLABLE JYU
+      | 0xEC 0xA6 0x88          #Lo       HANGUL SYLLABLE JEU
+      | 0xEC 0xA6 0xA4          #Lo       HANGUL SYLLABLE JYI
+      | 0xEC 0xA7 0x80          #Lo       HANGUL SYLLABLE JI
+      | 0xEC 0xA7 0x9C          #Lo       HANGUL SYLLABLE JJA
+      | 0xEC 0xA7 0xB8          #Lo       HANGUL SYLLABLE JJAE
+      | 0xEC 0xA8 0x94          #Lo       HANGUL SYLLABLE JJYA
+      | 0xEC 0xA8 0xB0          #Lo       HANGUL SYLLABLE JJYAE
+      | 0xEC 0xA9 0x8C          #Lo       HANGUL SYLLABLE JJEO
+      | 0xEC 0xA9 0xA8          #Lo       HANGUL SYLLABLE JJE
+      | 0xEC 0xAA 0x84          #Lo       HANGUL SYLLABLE JJYEO
+      | 0xEC 0xAA 0xA0          #Lo       HANGUL SYLLABLE JJYE
+      | 0xEC 0xAA 0xBC          #Lo       HANGUL SYLLABLE JJO
+      | 0xEC 0xAB 0x98          #Lo       HANGUL SYLLABLE JJWA
+      | 0xEC 0xAB 0xB4          #Lo       HANGUL SYLLABLE JJWAE
+      | 0xEC 0xAC 0x90          #Lo       HANGUL SYLLABLE JJOE
+      | 0xEC 0xAC 0xAC          #Lo       HANGUL SYLLABLE JJYO
+      | 0xEC 0xAD 0x88          #Lo       HANGUL SYLLABLE JJU
+      | 0xEC 0xAD 0xA4          #Lo       HANGUL SYLLABLE JJWEO
+      | 0xEC 0xAE 0x80          #Lo       HANGUL SYLLABLE JJWE
+      | 0xEC 0xAE 0x9C          #Lo       HANGUL SYLLABLE JJWI
+      | 0xEC 0xAE 0xB8          #Lo       HANGUL SYLLABLE JJYU
+      | 0xEC 0xAF 0x94          #Lo       HANGUL SYLLABLE JJEU
+      | 0xEC 0xAF 0xB0          #Lo       HANGUL SYLLABLE JJYI
+      | 0xEC 0xB0 0x8C          #Lo       HANGUL SYLLABLE JJI
+      | 0xEC 0xB0 0xA8          #Lo       HANGUL SYLLABLE CA
+      | 0xEC 0xB1 0x84          #Lo       HANGUL SYLLABLE CAE
+      | 0xEC 0xB1 0xA0          #Lo       HANGUL SYLLABLE CYA
+      | 0xEC 0xB1 0xBC          #Lo       HANGUL SYLLABLE CYAE
+      | 0xEC 0xB2 0x98          #Lo       HANGUL SYLLABLE CEO
+      | 0xEC 0xB2 0xB4          #Lo       HANGUL SYLLABLE CE
+      | 0xEC 0xB3 0x90          #Lo       HANGUL SYLLABLE CYEO
+      | 0xEC 0xB3 0xAC          #Lo       HANGUL SYLLABLE CYE
+      | 0xEC 0xB4 0x88          #Lo       HANGUL SYLLABLE CO
+      | 0xEC 0xB4 0xA4          #Lo       HANGUL SYLLABLE CWA
+      | 0xEC 0xB5 0x80          #Lo       HANGUL SYLLABLE CWAE
+      | 0xEC 0xB5 0x9C          #Lo       HANGUL SYLLABLE COE
+      | 0xEC 0xB5 0xB8          #Lo       HANGUL SYLLABLE CYO
+      | 0xEC 0xB6 0x94          #Lo       HANGUL SYLLABLE CU
+      | 0xEC 0xB6 0xB0          #Lo       HANGUL SYLLABLE CWEO
+      | 0xEC 0xB7 0x8C          #Lo       HANGUL SYLLABLE CWE
+      | 0xEC 0xB7 0xA8          #Lo       HANGUL SYLLABLE CWI
+      | 0xEC 0xB8 0x84          #Lo       HANGUL SYLLABLE CYU
+      | 0xEC 0xB8 0xA0          #Lo       HANGUL SYLLABLE CEU
+      | 0xEC 0xB8 0xBC          #Lo       HANGUL SYLLABLE CYI
+      | 0xEC 0xB9 0x98          #Lo       HANGUL SYLLABLE CI
+      | 0xEC 0xB9 0xB4          #Lo       HANGUL SYLLABLE KA
+      | 0xEC 0xBA 0x90          #Lo       HANGUL SYLLABLE KAE
+      | 0xEC 0xBA 0xAC          #Lo       HANGUL SYLLABLE KYA
+      | 0xEC 0xBB 0x88          #Lo       HANGUL SYLLABLE KYAE
+      | 0xEC 0xBB 0xA4          #Lo       HANGUL SYLLABLE KEO
+      | 0xEC 0xBC 0x80          #Lo       HANGUL SYLLABLE KE
+      | 0xEC 0xBC 0x9C          #Lo       HANGUL SYLLABLE KYEO
+      | 0xEC 0xBC 0xB8          #Lo       HANGUL SYLLABLE KYE
+      | 0xEC 0xBD 0x94          #Lo       HANGUL SYLLABLE KO
+      | 0xEC 0xBD 0xB0          #Lo       HANGUL SYLLABLE KWA
+      | 0xEC 0xBE 0x8C          #Lo       HANGUL SYLLABLE KWAE
+      | 0xEC 0xBE 0xA8          #Lo       HANGUL SYLLABLE KOE
+      | 0xEC 0xBF 0x84          #Lo       HANGUL SYLLABLE KYO
+      | 0xEC 0xBF 0xA0          #Lo       HANGUL SYLLABLE KU
+      | 0xEC 0xBF 0xBC          #Lo       HANGUL SYLLABLE KWEO
+      | 0xED 0x80 0x98          #Lo       HANGUL SYLLABLE KWE
+      | 0xED 0x80 0xB4          #Lo       HANGUL SYLLABLE KWI
+      | 0xED 0x81 0x90          #Lo       HANGUL SYLLABLE KYU
+      | 0xED 0x81 0xAC          #Lo       HANGUL SYLLABLE KEU
+      | 0xED 0x82 0x88          #Lo       HANGUL SYLLABLE KYI
+      | 0xED 0x82 0xA4          #Lo       HANGUL SYLLABLE KI
+      | 0xED 0x83 0x80          #Lo       HANGUL SYLLABLE TA
+      | 0xED 0x83 0x9C          #Lo       HANGUL SYLLABLE TAE
+      | 0xED 0x83 0xB8          #Lo       HANGUL SYLLABLE TYA
+      | 0xED 0x84 0x94          #Lo       HANGUL SYLLABLE TYAE
+      | 0xED 0x84 0xB0          #Lo       HANGUL SYLLABLE TEO
+      | 0xED 0x85 0x8C          #Lo       HANGUL SYLLABLE TE
+      | 0xED 0x85 0xA8          #Lo       HANGUL SYLLABLE TYEO
+      | 0xED 0x86 0x84          #Lo       HANGUL SYLLABLE TYE
+      | 0xED 0x86 0xA0          #Lo       HANGUL SYLLABLE TO
+      | 0xED 0x86 0xBC          #Lo       HANGUL SYLLABLE TWA
+      | 0xED 0x87 0x98          #Lo       HANGUL SYLLABLE TWAE
+      | 0xED 0x87 0xB4          #Lo       HANGUL SYLLABLE TOE
+      | 0xED 0x88 0x90          #Lo       HANGUL SYLLABLE TYO
+      | 0xED 0x88 0xAC          #Lo       HANGUL SYLLABLE TU
+      | 0xED 0x89 0x88          #Lo       HANGUL SYLLABLE TWEO
+      | 0xED 0x89 0xA4          #Lo       HANGUL SYLLABLE TWE
+      | 0xED 0x8A 0x80          #Lo       HANGUL SYLLABLE TWI
+      | 0xED 0x8A 0x9C          #Lo       HANGUL SYLLABLE TYU
+      | 0xED 0x8A 0xB8          #Lo       HANGUL SYLLABLE TEU
+      | 0xED 0x8B 0x94          #Lo       HANGUL SYLLABLE TYI
+      | 0xED 0x8B 0xB0          #Lo       HANGUL SYLLABLE TI
+      | 0xED 0x8C 0x8C          #Lo       HANGUL SYLLABLE PA
+      | 0xED 0x8C 0xA8          #Lo       HANGUL SYLLABLE PAE
+      | 0xED 0x8D 0x84          #Lo       HANGUL SYLLABLE PYA
+      | 0xED 0x8D 0xA0          #Lo       HANGUL SYLLABLE PYAE
+      | 0xED 0x8D 0xBC          #Lo       HANGUL SYLLABLE PEO
+      | 0xED 0x8E 0x98          #Lo       HANGUL SYLLABLE PE
+      | 0xED 0x8E 0xB4          #Lo       HANGUL SYLLABLE PYEO
+      | 0xED 0x8F 0x90          #Lo       HANGUL SYLLABLE PYE
+      | 0xED 0x8F 0xAC          #Lo       HANGUL SYLLABLE PO
+      | 0xED 0x90 0x88          #Lo       HANGUL SYLLABLE PWA
+      | 0xED 0x90 0xA4          #Lo       HANGUL SYLLABLE PWAE
+      | 0xED 0x91 0x80          #Lo       HANGUL SYLLABLE POE
+      | 0xED 0x91 0x9C          #Lo       HANGUL SYLLABLE PYO
+      | 0xED 0x91 0xB8          #Lo       HANGUL SYLLABLE PU
+      | 0xED 0x92 0x94          #Lo       HANGUL SYLLABLE PWEO
+      | 0xED 0x92 0xB0          #Lo       HANGUL SYLLABLE PWE
+      | 0xED 0x93 0x8C          #Lo       HANGUL SYLLABLE PWI
+      | 0xED 0x93 0xA8          #Lo       HANGUL SYLLABLE PYU
+      | 0xED 0x94 0x84          #Lo       HANGUL SYLLABLE PEU
+      | 0xED 0x94 0xA0          #Lo       HANGUL SYLLABLE PYI
+      | 0xED 0x94 0xBC          #Lo       HANGUL SYLLABLE PI
+      | 0xED 0x95 0x98          #Lo       HANGUL SYLLABLE HA
+      | 0xED 0x95 0xB4          #Lo       HANGUL SYLLABLE HAE
+      | 0xED 0x96 0x90          #Lo       HANGUL SYLLABLE HYA
+      | 0xED 0x96 0xAC          #Lo       HANGUL SYLLABLE HYAE
+      | 0xED 0x97 0x88          #Lo       HANGUL SYLLABLE HEO
+      | 0xED 0x97 0xA4          #Lo       HANGUL SYLLABLE HE
+      | 0xED 0x98 0x80          #Lo       HANGUL SYLLABLE HYEO
+      | 0xED 0x98 0x9C          #Lo       HANGUL SYLLABLE HYE
+      | 0xED 0x98 0xB8          #Lo       HANGUL SYLLABLE HO
+      | 0xED 0x99 0x94          #Lo       HANGUL SYLLABLE HWA
+      | 0xED 0x99 0xB0          #Lo       HANGUL SYLLABLE HWAE
+      | 0xED 0x9A 0x8C          #Lo       HANGUL SYLLABLE HOE
+      | 0xED 0x9A 0xA8          #Lo       HANGUL SYLLABLE HYO
+      | 0xED 0x9B 0x84          #Lo       HANGUL SYLLABLE HU
+      | 0xED 0x9B 0xA0          #Lo       HANGUL SYLLABLE HWEO
+      | 0xED 0x9B 0xBC          #Lo       HANGUL SYLLABLE HWE
+      | 0xED 0x9C 0x98          #Lo       HANGUL SYLLABLE HWI
+      | 0xED 0x9C 0xB4          #Lo       HANGUL SYLLABLE HYU
+      | 0xED 0x9D 0x90          #Lo       HANGUL SYLLABLE HEU
+      | 0xED 0x9D 0xAC          #Lo       HANGUL SYLLABLE HYI
+      | 0xED 0x9E 0x88          #Lo       HANGUL SYLLABLE HI
+      ;
+
+    LVT = 
+        0xEA 0xB0 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE GAG..HANGUL SYLLAB...
+      | 0xEA 0xB0 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE GAEG..HANGUL SYLLA...
+      | 0xEA 0xB0 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE GYAG..HANGUL SYLLA...
+      | 0xEA 0xB1 0x00..0x93    #
+      | 0xEA 0xB1 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE GYAEG..HANGUL SYLL...
+      | 0xEA 0xB1 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE GEOG..HANGUL SYLLA...
+      | 0xEA 0xB2 0x00..0x8B    #
+      | 0xEA 0xB2 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE GEG..HANGUL SYLLAB...
+      | 0xEA 0xB2 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE GYEOG..HANGUL SYLL...
+      | 0xEA 0xB3 0x00..0x83    #
+      | 0xEA 0xB3 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE GYEG..HANGUL SYLLA...
+      | 0xEA 0xB3 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE GOG..HANGUL SYLLAB...
+      | 0xEA 0xB3 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE GWAG..HANGUL SYLLA...
+      | 0xEA 0xB4 0x00..0x97    #
+      | 0xEA 0xB4 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE GWAEG..HANGUL SYLL...
+      | 0xEA 0xB4 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE GOEG..HANGUL SYLLA...
+      | 0xEA 0xB5 0x00..0x8F    #
+      | 0xEA 0xB5 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE GYOG..HANGUL SYLLA...
+      | 0xEA 0xB5 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE GUG..HANGUL SYLLAB...
+      | 0xEA 0xB6 0x00..0x87    #
+      | 0xEA 0xB6 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE GWEOG..HANGUL SYLL...
+      | 0xEA 0xB6 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE GWEG..HANGUL SYLLA...
+      | 0xEA 0xB7 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE GWIG..HANGUL SYLLA...
+      | 0xEA 0xB7 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE GYUG..HANGUL SYLLA...
+      | 0xEA 0xB7 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE GEUG..HANGUL SYLLA...
+      | 0xEA 0xB8 0x00..0x93    #
+      | 0xEA 0xB8 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE GYIG..HANGUL SYLLA...
+      | 0xEA 0xB8 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE GIG..HANGUL SYLLAB...
+      | 0xEA 0xB9 0x00..0x8B    #
+      | 0xEA 0xB9 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE GGAG..HANGUL SYLLA...
+      | 0xEA 0xB9 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE GGAEG..HANGUL SYLL...
+      | 0xEA 0xBA 0x00..0x83    #
+      | 0xEA 0xBA 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE GGYAG..HANGUL SYLL...
+      | 0xEA 0xBA 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE GGYAEG..HANGUL SYL...
+      | 0xEA 0xBA 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE GGEOG..HANGUL SYLL...
+      | 0xEA 0xBB 0x00..0x97    #
+      | 0xEA 0xBB 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE GGEG..HANGUL SYLLA...
+      | 0xEA 0xBB 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE GGYEOG..HANGUL SYL...
+      | 0xEA 0xBC 0x00..0x8F    #
+      | 0xEA 0xBC 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE GGYEG..HANGUL SYLL...
+      | 0xEA 0xBC 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE GGOG..HANGUL SYLLA...
+      | 0xEA 0xBD 0x00..0x87    #
+      | 0xEA 0xBD 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE GGWAG..HANGUL SYLL...
+      | 0xEA 0xBD 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE GGWAEG..HANGUL SYL...
+      | 0xEA 0xBE 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE GGOEG..HANGUL SYLL...
+      | 0xEA 0xBE 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE GGYOG..HANGUL SYLL...
+      | 0xEA 0xBE 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE GGUG..HANGUL SYLLA...
+      | 0xEA 0xBF 0x00..0x93    #
+      | 0xEA 0xBF 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE GGWEOG..HANGUL SYL...
+      | 0xEA 0xBF 0xB1..0xFF        #Lo  [27] HANGUL SYLLABLE GGWEG..HANGUL ...
+      | 0xEA 0xC0..0xFF 0x00..0xFF  #
+      | 0xEB 0x00 0x00..0xFF        #
+      | 0xEB 0x01..0x7F 0x00..0xFF  #
+      | 0xEB 0x80 0x00..0x8B        #
+      | 0xEB 0x80 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE GGWIG..HANGUL SYLL...
+      | 0xEB 0x80 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE GGYUG..HANGUL SYLL...
+      | 0xEB 0x81 0x00..0x83    #
+      | 0xEB 0x81 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE GGEUG..HANGUL SYLL...
+      | 0xEB 0x81 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE GGYIG..HANGUL SYLL...
+      | 0xEB 0x81 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE GGIG..HANGUL SYLLA...
+      | 0xEB 0x82 0x00..0x97    #
+      | 0xEB 0x82 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE NAG..HANGUL SYLLAB...
+      | 0xEB 0x82 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE NAEG..HANGUL SYLLA...
+      | 0xEB 0x83 0x00..0x8F    #
+      | 0xEB 0x83 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE NYAG..HANGUL SYLLA...
+      | 0xEB 0x83 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE NYAEG..HANGUL SYLL...
+      | 0xEB 0x84 0x00..0x87    #
+      | 0xEB 0x84 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE NEOG..HANGUL SYLLA...
+      | 0xEB 0x84 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE NEG..HANGUL SYLLAB...
+      | 0xEB 0x85 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE NYEOG..HANGUL SYLL...
+      | 0xEB 0x85 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE NYEG..HANGUL SYLLA...
+      | 0xEB 0x85 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE NOG..HANGUL SYLLAB...
+      | 0xEB 0x86 0x00..0x93    #
+      | 0xEB 0x86 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE NWAG..HANGUL SYLLA...
+      | 0xEB 0x86 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE NWAEG..HANGUL SYLL...
+      | 0xEB 0x87 0x00..0x8B    #
+      | 0xEB 0x87 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE NOEG..HANGUL SYLLA...
+      | 0xEB 0x87 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE NYOG..HANGUL SYLLA...
+      | 0xEB 0x88 0x00..0x83    #
+      | 0xEB 0x88 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE NUG..HANGUL SYLLAB...
+      | 0xEB 0x88 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE NWEOG..HANGUL SYLL...
+      | 0xEB 0x88 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE NWEG..HANGUL SYLLA...
+      | 0xEB 0x89 0x00..0x97    #
+      | 0xEB 0x89 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE NWIG..HANGUL SYLLA...
+      | 0xEB 0x89 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE NYUG..HANGUL SYLLA...
+      | 0xEB 0x8A 0x00..0x8F    #
+      | 0xEB 0x8A 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE NEUG..HANGUL SYLLA...
+      | 0xEB 0x8A 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE NYIG..HANGUL SYLLA...
+      | 0xEB 0x8B 0x00..0x87    #
+      | 0xEB 0x8B 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE NIG..HANGUL SYLLAB...
+      | 0xEB 0x8B 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE DAG..HANGUL SYLLAB...
+      | 0xEB 0x8C 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE DAEG..HANGUL SYLLA...
+      | 0xEB 0x8C 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE DYAG..HANGUL SYLLA...
+      | 0xEB 0x8C 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE DYAEG..HANGUL SYLL...
+      | 0xEB 0x8D 0x00..0x93    #
+      | 0xEB 0x8D 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE DEOG..HANGUL SYLLA...
+      | 0xEB 0x8D 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE DEG..HANGUL SYLLAB...
+      | 0xEB 0x8E 0x00..0x8B    #
+      | 0xEB 0x8E 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE DYEOG..HANGUL SYLL...
+      | 0xEB 0x8E 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE DYEG..HANGUL SYLLA...
+      | 0xEB 0x8F 0x00..0x83    #
+      | 0xEB 0x8F 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE DOG..HANGUL SYLLAB...
+      | 0xEB 0x8F 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE DWAG..HANGUL SYLLA...
+      | 0xEB 0x8F 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE DWAEG..HANGUL SYLL...
+      | 0xEB 0x90 0x00..0x97    #
+      | 0xEB 0x90 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE DOEG..HANGUL SYLLA...
+      | 0xEB 0x90 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE DYOG..HANGUL SYLLA...
+      | 0xEB 0x91 0x00..0x8F    #
+      | 0xEB 0x91 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE DUG..HANGUL SYLLAB...
+      | 0xEB 0x91 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE DWEOG..HANGUL SYLL...
+      | 0xEB 0x92 0x00..0x87    #
+      | 0xEB 0x92 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE DWEG..HANGUL SYLLA...
+      | 0xEB 0x92 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE DWIG..HANGUL SYLLA...
+      | 0xEB 0x93 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE DYUG..HANGUL SYLLA...
+      | 0xEB 0x93 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE DEUG..HANGUL SYLLA...
+      | 0xEB 0x93 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE DYIG..HANGUL SYLLA...
+      | 0xEB 0x94 0x00..0x93    #
+      | 0xEB 0x94 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE DIG..HANGUL SYLLAB...
+      | 0xEB 0x94 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE DDAG..HANGUL SYLLA...
+      | 0xEB 0x95 0x00..0x8B    #
+      | 0xEB 0x95 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE DDAEG..HANGUL SYLL...
+      | 0xEB 0x95 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE DDYAG..HANGUL SYLL...
+      | 0xEB 0x96 0x00..0x83    #
+      | 0xEB 0x96 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE DDYAEG..HANGUL SYL...
+      | 0xEB 0x96 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE DDEOG..HANGUL SYLL...
+      | 0xEB 0x96 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE DDEG..HANGUL SYLLA...
+      | 0xEB 0x97 0x00..0x97    #
+      | 0xEB 0x97 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE DDYEOG..HANGUL SYL...
+      | 0xEB 0x97 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE DDYEG..HANGUL SYLL...
+      | 0xEB 0x98 0x00..0x8F    #
+      | 0xEB 0x98 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE DDOG..HANGUL SYLLA...
+      | 0xEB 0x98 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE DDWAG..HANGUL SYLL...
+      | 0xEB 0x99 0x00..0x87    #
+      | 0xEB 0x99 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE DDWAEG..HANGUL SYL...
+      | 0xEB 0x99 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE DDOEG..HANGUL SYLL...
+      | 0xEB 0x9A 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE DDYOG..HANGUL SYLL...
+      | 0xEB 0x9A 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE DDUG..HANGUL SYLLA...
+      | 0xEB 0x9A 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE DDWEOG..HANGUL SYL...
+      | 0xEB 0x9B 0x00..0x93    #
+      | 0xEB 0x9B 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE DDWEG..HANGUL SYLL...
+      | 0xEB 0x9B 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE DDWIG..HANGUL SYLL...
+      | 0xEB 0x9C 0x00..0x8B    #
+      | 0xEB 0x9C 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE DDYUG..HANGUL SYLL...
+      | 0xEB 0x9C 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE DDEUG..HANGUL SYLL...
+      | 0xEB 0x9D 0x00..0x83    #
+      | 0xEB 0x9D 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE DDYIG..HANGUL SYLL...
+      | 0xEB 0x9D 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE DDIG..HANGUL SYLLA...
+      | 0xEB 0x9D 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE RAG..HANGUL SYLLAB...
+      | 0xEB 0x9E 0x00..0x97    #
+      | 0xEB 0x9E 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE RAEG..HANGUL SYLLA...
+      | 0xEB 0x9E 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE RYAG..HANGUL SYLLA...
+      | 0xEB 0x9F 0x00..0x8F    #
+      | 0xEB 0x9F 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE RYAEG..HANGUL SYLL...
+      | 0xEB 0x9F 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE REOG..HANGUL SYLLA...
+      | 0xEB 0xA0 0x00..0x87    #
+      | 0xEB 0xA0 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE REG..HANGUL SYLLAB...
+      | 0xEB 0xA0 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE RYEOG..HANGUL SYLL...
+      | 0xEB 0xA1 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE RYEG..HANGUL SYLLA...
+      | 0xEB 0xA1 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE ROG..HANGUL SYLLAB...
+      | 0xEB 0xA1 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE RWAG..HANGUL SYLLA...
+      | 0xEB 0xA2 0x00..0x93    #
+      | 0xEB 0xA2 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE RWAEG..HANGUL SYLL...
+      | 0xEB 0xA2 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE ROEG..HANGUL SYLLA...
+      | 0xEB 0xA3 0x00..0x8B    #
+      | 0xEB 0xA3 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE RYOG..HANGUL SYLLA...
+      | 0xEB 0xA3 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE RUG..HANGUL SYLLAB...
+      | 0xEB 0xA4 0x00..0x83    #
+      | 0xEB 0xA4 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE RWEOG..HANGUL SYLL...
+      | 0xEB 0xA4 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE RWEG..HANGUL SYLLA...
+      | 0xEB 0xA4 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE RWIG..HANGUL SYLLA...
+      | 0xEB 0xA5 0x00..0x97    #
+      | 0xEB 0xA5 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE RYUG..HANGUL SYLLA...
+      | 0xEB 0xA5 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE REUG..HANGUL SYLLA...
+      | 0xEB 0xA6 0x00..0x8F    #
+      | 0xEB 0xA6 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE RYIG..HANGUL SYLLA...
+      | 0xEB 0xA6 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE RIG..HANGUL SYLLAB...
+      | 0xEB 0xA7 0x00..0x87    #
+      | 0xEB 0xA7 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE MAG..HANGUL SYLLAB...
+      | 0xEB 0xA7 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE MAEG..HANGUL SYLLA...
+      | 0xEB 0xA8 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE MYAG..HANGUL SYLLA...
+      | 0xEB 0xA8 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE MYAEG..HANGUL SYLL...
+      | 0xEB 0xA8 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE MEOG..HANGUL SYLLA...
+      | 0xEB 0xA9 0x00..0x93    #
+      | 0xEB 0xA9 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE MEG..HANGUL SYLLAB...
+      | 0xEB 0xA9 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE MYEOG..HANGUL SYLL...
+      | 0xEB 0xAA 0x00..0x8B    #
+      | 0xEB 0xAA 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE MYEG..HANGUL SYLLA...
+      | 0xEB 0xAA 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE MOG..HANGUL SYLLAB...
+      | 0xEB 0xAB 0x00..0x83    #
+      | 0xEB 0xAB 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE MWAG..HANGUL SYLLA...
+      | 0xEB 0xAB 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE MWAEG..HANGUL SYLL...
+      | 0xEB 0xAB 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE MOEG..HANGUL SYLLA...
+      | 0xEB 0xAC 0x00..0x97    #
+      | 0xEB 0xAC 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE MYOG..HANGUL SYLLA...
+      | 0xEB 0xAC 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE MUG..HANGUL SYLLAB...
+      | 0xEB 0xAD 0x00..0x8F    #
+      | 0xEB 0xAD 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE MWEOG..HANGUL SYLL...
+      | 0xEB 0xAD 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE MWEG..HANGUL SYLLA...
+      | 0xEB 0xAE 0x00..0x87    #
+      | 0xEB 0xAE 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE MWIG..HANGUL SYLLA...
+      | 0xEB 0xAE 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE MYUG..HANGUL SYLLA...
+      | 0xEB 0xAF 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE MEUG..HANGUL SYLLA...
+      | 0xEB 0xAF 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE MYIG..HANGUL SYLLA...
+      | 0xEB 0xAF 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE MIG..HANGUL SYLLAB...
+      | 0xEB 0xB0 0x00..0x93    #
+      | 0xEB 0xB0 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE BAG..HANGUL SYLLAB...
+      | 0xEB 0xB0 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE BAEG..HANGUL SYLLA...
+      | 0xEB 0xB1 0x00..0x8B    #
+      | 0xEB 0xB1 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE BYAG..HANGUL SYLLA...
+      | 0xEB 0xB1 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE BYAEG..HANGUL SYLL...
+      | 0xEB 0xB2 0x00..0x83    #
+      | 0xEB 0xB2 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE BEOG..HANGUL SYLLA...
+      | 0xEB 0xB2 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE BEG..HANGUL SYLLAB...
+      | 0xEB 0xB2 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE BYEOG..HANGUL SYLL...
+      | 0xEB 0xB3 0x00..0x97    #
+      | 0xEB 0xB3 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE BYEG..HANGUL SYLLA...
+      | 0xEB 0xB3 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE BOG..HANGUL SYLLAB...
+      | 0xEB 0xB4 0x00..0x8F    #
+      | 0xEB 0xB4 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE BWAG..HANGUL SYLLA...
+      | 0xEB 0xB4 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE BWAEG..HANGUL SYLL...
+      | 0xEB 0xB5 0x00..0x87    #
+      | 0xEB 0xB5 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE BOEG..HANGUL SYLLA...
+      | 0xEB 0xB5 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE BYOG..HANGUL SYLLA...
+      | 0xEB 0xB6 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE BUG..HANGUL SYLLAB...
+      | 0xEB 0xB6 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE BWEOG..HANGUL SYLL...
+      | 0xEB 0xB6 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE BWEG..HANGUL SYLLA...
+      | 0xEB 0xB7 0x00..0x93    #
+      | 0xEB 0xB7 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE BWIG..HANGUL SYLLA...
+      | 0xEB 0xB7 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE BYUG..HANGUL SYLLA...
+      | 0xEB 0xB8 0x00..0x8B    #
+      | 0xEB 0xB8 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE BEUG..HANGUL SYLLA...
+      | 0xEB 0xB8 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE BYIG..HANGUL SYLLA...
+      | 0xEB 0xB9 0x00..0x83    #
+      | 0xEB 0xB9 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE BIG..HANGUL SYLLAB...
+      | 0xEB 0xB9 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE BBAG..HANGUL SYLLA...
+      | 0xEB 0xB9 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE BBAEG..HANGUL SYLL...
+      | 0xEB 0xBA 0x00..0x97    #
+      | 0xEB 0xBA 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE BBYAG..HANGUL SYLL...
+      | 0xEB 0xBA 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE BBYAEG..HANGUL SYL...
+      | 0xEB 0xBB 0x00..0x8F    #
+      | 0xEB 0xBB 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE BBEOG..HANGUL SYLL...
+      | 0xEB 0xBB 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE BBEG..HANGUL SYLLA...
+      | 0xEB 0xBC 0x00..0x87    #
+      | 0xEB 0xBC 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE BBYEOG..HANGUL SYL...
+      | 0xEB 0xBC 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE BBYEG..HANGUL SYLL...
+      | 0xEB 0xBD 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE BBOG..HANGUL SYLLA...
+      | 0xEB 0xBD 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE BBWAG..HANGUL SYLL...
+      | 0xEB 0xBD 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE BBWAEG..HANGUL SYL...
+      | 0xEB 0xBE 0x00..0x93    #
+      | 0xEB 0xBE 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE BBOEG..HANGUL SYLL...
+      | 0xEB 0xBE 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE BBYOG..HANGUL SYLL...
+      | 0xEB 0xBF 0x00..0x8B    #
+      | 0xEB 0xBF 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE BBUG..HANGUL SYLLA...
+      | 0xEB 0xBF 0xA9..0xFF        #Lo  [27] HANGUL SYLLABLE BBWEOG..HANGUL...
+      | 0xEB 0xC0..0xFF 0x00..0xFF  #
+      | 0xEC 0x00 0x00..0xFF        #
+      | 0xEC 0x01..0x7F 0x00..0xFF  #
+      | 0xEC 0x80 0x00..0x83        #
+      | 0xEC 0x80 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE BBWEG..HANGUL SYLL...
+      | 0xEC 0x80 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE BBWIG..HANGUL SYLL...
+      | 0xEC 0x80 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE BBYUG..HANGUL SYLL...
+      | 0xEC 0x81 0x00..0x97    #
+      | 0xEC 0x81 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE BBEUG..HANGUL SYLL...
+      | 0xEC 0x81 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE BBYIG..HANGUL SYLL...
+      | 0xEC 0x82 0x00..0x8F    #
+      | 0xEC 0x82 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE BBIG..HANGUL SYLLA...
+      | 0xEC 0x82 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE SAG..HANGUL SYLLAB...
+      | 0xEC 0x83 0x00..0x87    #
+      | 0xEC 0x83 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE SAEG..HANGUL SYLLA...
+      | 0xEC 0x83 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE SYAG..HANGUL SYLLA...
+      | 0xEC 0x84 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE SYAEG..HANGUL SYLL...
+      | 0xEC 0x84 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE SEOG..HANGUL SYLLA...
+      | 0xEC 0x84 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE SEG..HANGUL SYLLAB...
+      | 0xEC 0x85 0x00..0x93    #
+      | 0xEC 0x85 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE SYEOG..HANGUL SYLL...
+      | 0xEC 0x85 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE SYEG..HANGUL SYLLA...
+      | 0xEC 0x86 0x00..0x8B    #
+      | 0xEC 0x86 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE SOG..HANGUL SYLLAB...
+      | 0xEC 0x86 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE SWAG..HANGUL SYLLA...
+      | 0xEC 0x87 0x00..0x83    #
+      | 0xEC 0x87 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE SWAEG..HANGUL SYLL...
+      | 0xEC 0x87 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE SOEG..HANGUL SYLLA...
+      | 0xEC 0x87 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE SYOG..HANGUL SYLLA...
+      | 0xEC 0x88 0x00..0x97    #
+      | 0xEC 0x88 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE SUG..HANGUL SYLLAB...
+      | 0xEC 0x88 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE SWEOG..HANGUL SYLL...
+      | 0xEC 0x89 0x00..0x8F    #
+      | 0xEC 0x89 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE SWEG..HANGUL SYLLA...
+      | 0xEC 0x89 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE SWIG..HANGUL SYLLA...
+      | 0xEC 0x8A 0x00..0x87    #
+      | 0xEC 0x8A 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE SYUG..HANGUL SYLLA...
+      | 0xEC 0x8A 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE SEUG..HANGUL SYLLA...
+      | 0xEC 0x8B 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE SYIG..HANGUL SYLLA...
+      | 0xEC 0x8B 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE SIG..HANGUL SYLLAB...
+      | 0xEC 0x8B 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE SSAG..HANGUL SYLLA...
+      | 0xEC 0x8C 0x00..0x93    #
+      | 0xEC 0x8C 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE SSAEG..HANGUL SYLL...
+      | 0xEC 0x8C 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE SSYAG..HANGUL SYLL...
+      | 0xEC 0x8D 0x00..0x8B    #
+      | 0xEC 0x8D 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE SSYAEG..HANGUL SYL...
+      | 0xEC 0x8D 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE SSEOG..HANGUL SYLL...
+      | 0xEC 0x8E 0x00..0x83    #
+      | 0xEC 0x8E 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE SSEG..HANGUL SYLLA...
+      | 0xEC 0x8E 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE SSYEOG..HANGUL SYL...
+      | 0xEC 0x8E 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE SSYEG..HANGUL SYLL...
+      | 0xEC 0x8F 0x00..0x97    #
+      | 0xEC 0x8F 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE SSOG..HANGUL SYLLA...
+      | 0xEC 0x8F 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE SSWAG..HANGUL SYLL...
+      | 0xEC 0x90 0x00..0x8F    #
+      | 0xEC 0x90 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE SSWAEG..HANGUL SYL...
+      | 0xEC 0x90 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE SSOEG..HANGUL SYLL...
+      | 0xEC 0x91 0x00..0x87    #
+      | 0xEC 0x91 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE SSYOG..HANGUL SYLL...
+      | 0xEC 0x91 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE SSUG..HANGUL SYLLA...
+      | 0xEC 0x92 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE SSWEOG..HANGUL SYL...
+      | 0xEC 0x92 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE SSWEG..HANGUL SYLL...
+      | 0xEC 0x92 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE SSWIG..HANGUL SYLL...
+      | 0xEC 0x93 0x00..0x93    #
+      | 0xEC 0x93 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE SSYUG..HANGUL SYLL...
+      | 0xEC 0x93 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE SSEUG..HANGUL SYLL...
+      | 0xEC 0x94 0x00..0x8B    #
+      | 0xEC 0x94 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE SSYIG..HANGUL SYLL...
+      | 0xEC 0x94 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE SSIG..HANGUL SYLLA...
+      | 0xEC 0x95 0x00..0x83    #
+      | 0xEC 0x95 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE AG..HANGUL SYLLABL...
+      | 0xEC 0x95 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE AEG..HANGUL SYLLAB...
+      | 0xEC 0x95 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE YAG..HANGUL SYLLAB...
+      | 0xEC 0x96 0x00..0x97    #
+      | 0xEC 0x96 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE YAEG..HANGUL SYLLA...
+      | 0xEC 0x96 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE EOG..HANGUL SYLLAB...
+      | 0xEC 0x97 0x00..0x8F    #
+      | 0xEC 0x97 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE EG..HANGUL SYLLABL...
+      | 0xEC 0x97 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE YEOG..HANGUL SYLLA...
+      | 0xEC 0x98 0x00..0x87    #
+      | 0xEC 0x98 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE YEG..HANGUL SYLLAB...
+      | 0xEC 0x98 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE OG..HANGUL SYLLABL...
+      | 0xEC 0x99 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE WAG..HANGUL SYLLAB...
+      | 0xEC 0x99 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE WAEG..HANGUL SYLLA...
+      | 0xEC 0x99 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE OEG..HANGUL SYLLAB...
+      | 0xEC 0x9A 0x00..0x93    #
+      | 0xEC 0x9A 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE YOG..HANGUL SYLLAB...
+      | 0xEC 0x9A 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE UG..HANGUL SYLLABL...
+      | 0xEC 0x9B 0x00..0x8B    #
+      | 0xEC 0x9B 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE WEOG..HANGUL SYLLA...
+      | 0xEC 0x9B 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE WEG..HANGUL SYLLAB...
+      | 0xEC 0x9C 0x00..0x83    #
+      | 0xEC 0x9C 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE WIG..HANGUL SYLLAB...
+      | 0xEC 0x9C 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE YUG..HANGUL SYLLAB...
+      | 0xEC 0x9C 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE EUG..HANGUL SYLLAB...
+      | 0xEC 0x9D 0x00..0x97    #
+      | 0xEC 0x9D 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE YIG..HANGUL SYLLAB...
+      | 0xEC 0x9D 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE IG..HANGUL SYLLABL...
+      | 0xEC 0x9E 0x00..0x8F    #
+      | 0xEC 0x9E 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE JAG..HANGUL SYLLAB...
+      | 0xEC 0x9E 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE JAEG..HANGUL SYLLA...
+      | 0xEC 0x9F 0x00..0x87    #
+      | 0xEC 0x9F 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE JYAG..HANGUL SYLLA...
+      | 0xEC 0x9F 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE JYAEG..HANGUL SYLL...
+      | 0xEC 0xA0 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE JEOG..HANGUL SYLLA...
+      | 0xEC 0xA0 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE JEG..HANGUL SYLLAB...
+      | 0xEC 0xA0 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE JYEOG..HANGUL SYLL...
+      | 0xEC 0xA1 0x00..0x93    #
+      | 0xEC 0xA1 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE JYEG..HANGUL SYLLA...
+      | 0xEC 0xA1 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE JOG..HANGUL SYLLAB...
+      | 0xEC 0xA2 0x00..0x8B    #
+      | 0xEC 0xA2 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE JWAG..HANGUL SYLLA...
+      | 0xEC 0xA2 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE JWAEG..HANGUL SYLL...
+      | 0xEC 0xA3 0x00..0x83    #
+      | 0xEC 0xA3 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE JOEG..HANGUL SYLLA...
+      | 0xEC 0xA3 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE JYOG..HANGUL SYLLA...
+      | 0xEC 0xA3 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE JUG..HANGUL SYLLAB...
+      | 0xEC 0xA4 0x00..0x97    #
+      | 0xEC 0xA4 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE JWEOG..HANGUL SYLL...
+      | 0xEC 0xA4 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE JWEG..HANGUL SYLLA...
+      | 0xEC 0xA5 0x00..0x8F    #
+      | 0xEC 0xA5 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE JWIG..HANGUL SYLLA...
+      | 0xEC 0xA5 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE JYUG..HANGUL SYLLA...
+      | 0xEC 0xA6 0x00..0x87    #
+      | 0xEC 0xA6 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE JEUG..HANGUL SYLLA...
+      | 0xEC 0xA6 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE JYIG..HANGUL SYLLA...
+      | 0xEC 0xA7 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE JIG..HANGUL SYLLAB...
+      | 0xEC 0xA7 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE JJAG..HANGUL SYLLA...
+      | 0xEC 0xA7 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE JJAEG..HANGUL SYLL...
+      | 0xEC 0xA8 0x00..0x93    #
+      | 0xEC 0xA8 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE JJYAG..HANGUL SYLL...
+      | 0xEC 0xA8 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE JJYAEG..HANGUL SYL...
+      | 0xEC 0xA9 0x00..0x8B    #
+      | 0xEC 0xA9 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE JJEOG..HANGUL SYLL...
+      | 0xEC 0xA9 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE JJEG..HANGUL SYLLA...
+      | 0xEC 0xAA 0x00..0x83    #
+      | 0xEC 0xAA 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE JJYEOG..HANGUL SYL...
+      | 0xEC 0xAA 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE JJYEG..HANGUL SYLL...
+      | 0xEC 0xAA 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE JJOG..HANGUL SYLLA...
+      | 0xEC 0xAB 0x00..0x97    #
+      | 0xEC 0xAB 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE JJWAG..HANGUL SYLL...
+      | 0xEC 0xAB 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE JJWAEG..HANGUL SYL...
+      | 0xEC 0xAC 0x00..0x8F    #
+      | 0xEC 0xAC 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE JJOEG..HANGUL SYLL...
+      | 0xEC 0xAC 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE JJYOG..HANGUL SYLL...
+      | 0xEC 0xAD 0x00..0x87    #
+      | 0xEC 0xAD 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE JJUG..HANGUL SYLLA...
+      | 0xEC 0xAD 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE JJWEOG..HANGUL SYL...
+      | 0xEC 0xAE 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE JJWEG..HANGUL SYLL...
+      | 0xEC 0xAE 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE JJWIG..HANGUL SYLL...
+      | 0xEC 0xAE 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE JJYUG..HANGUL SYLL...
+      | 0xEC 0xAF 0x00..0x93    #
+      | 0xEC 0xAF 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE JJEUG..HANGUL SYLL...
+      | 0xEC 0xAF 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE JJYIG..HANGUL SYLL...
+      | 0xEC 0xB0 0x00..0x8B    #
+      | 0xEC 0xB0 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE JJIG..HANGUL SYLLA...
+      | 0xEC 0xB0 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE CAG..HANGUL SYLLAB...
+      | 0xEC 0xB1 0x00..0x83    #
+      | 0xEC 0xB1 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE CAEG..HANGUL SYLLA...
+      | 0xEC 0xB1 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE CYAG..HANGUL SYLLA...
+      | 0xEC 0xB1 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE CYAEG..HANGUL SYLL...
+      | 0xEC 0xB2 0x00..0x97    #
+      | 0xEC 0xB2 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE CEOG..HANGUL SYLLA...
+      | 0xEC 0xB2 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE CEG..HANGUL SYLLAB...
+      | 0xEC 0xB3 0x00..0x8F    #
+      | 0xEC 0xB3 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE CYEOG..HANGUL SYLL...
+      | 0xEC 0xB3 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE CYEG..HANGUL SYLLA...
+      | 0xEC 0xB4 0x00..0x87    #
+      | 0xEC 0xB4 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE COG..HANGUL SYLLAB...
+      | 0xEC 0xB4 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE CWAG..HANGUL SYLLA...
+      | 0xEC 0xB5 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE CWAEG..HANGUL SYLL...
+      | 0xEC 0xB5 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE COEG..HANGUL SYLLA...
+      | 0xEC 0xB5 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE CYOG..HANGUL SYLLA...
+      | 0xEC 0xB6 0x00..0x93    #
+      | 0xEC 0xB6 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE CUG..HANGUL SYLLAB...
+      | 0xEC 0xB6 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE CWEOG..HANGUL SYLL...
+      | 0xEC 0xB7 0x00..0x8B    #
+      | 0xEC 0xB7 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE CWEG..HANGUL SYLLA...
+      | 0xEC 0xB7 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE CWIG..HANGUL SYLLA...
+      | 0xEC 0xB8 0x00..0x83    #
+      | 0xEC 0xB8 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE CYUG..HANGUL SYLLA...
+      | 0xEC 0xB8 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE CEUG..HANGUL SYLLA...
+      | 0xEC 0xB8 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE CYIG..HANGUL SYLLA...
+      | 0xEC 0xB9 0x00..0x97    #
+      | 0xEC 0xB9 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE CIG..HANGUL SYLLAB...
+      | 0xEC 0xB9 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE KAG..HANGUL SYLLAB...
+      | 0xEC 0xBA 0x00..0x8F    #
+      | 0xEC 0xBA 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE KAEG..HANGUL SYLLA...
+      | 0xEC 0xBA 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE KYAG..HANGUL SYLLA...
+      | 0xEC 0xBB 0x00..0x87    #
+      | 0xEC 0xBB 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE KYAEG..HANGUL SYLL...
+      | 0xEC 0xBB 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE KEOG..HANGUL SYLLA...
+      | 0xEC 0xBC 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE KEG..HANGUL SYLLAB...
+      | 0xEC 0xBC 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE KYEOG..HANGUL SYLL...
+      | 0xEC 0xBC 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE KYEG..HANGUL SYLLA...
+      | 0xEC 0xBD 0x00..0x93    #
+      | 0xEC 0xBD 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE KOG..HANGUL SYLLAB...
+      | 0xEC 0xBD 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE KWAG..HANGUL SYLLA...
+      | 0xEC 0xBE 0x00..0x8B    #
+      | 0xEC 0xBE 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE KWAEG..HANGUL SYLL...
+      | 0xEC 0xBE 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE KOEG..HANGUL SYLLA...
+      | 0xEC 0xBF 0x00..0x83    #
+      | 0xEC 0xBF 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE KYOG..HANGUL SYLLA...
+      | 0xEC 0xBF 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE KUG..HANGUL SYLLAB...
+      | 0xEC 0xBF 0xBD..0xFF        #Lo  [27] HANGUL SYLLABLE KWEOG..HANGUL ...
+      | 0xEC 0xC0..0xFF 0x00..0xFF  #
+      | 0xED 0x00 0x00..0xFF        #
+      | 0xED 0x01..0x7F 0x00..0xFF  #
+      | 0xED 0x80 0x00..0x97        #
+      | 0xED 0x80 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE KWEG..HANGUL SYLLA...
+      | 0xED 0x80 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE KWIG..HANGUL SYLLA...
+      | 0xED 0x81 0x00..0x8F    #
+      | 0xED 0x81 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE KYUG..HANGUL SYLLA...
+      | 0xED 0x81 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE KEUG..HANGUL SYLLA...
+      | 0xED 0x82 0x00..0x87    #
+      | 0xED 0x82 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE KYIG..HANGUL SYLLA...
+      | 0xED 0x82 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE KIG..HANGUL SYLLAB...
+      | 0xED 0x83 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE TAG..HANGUL SYLLAB...
+      | 0xED 0x83 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE TAEG..HANGUL SYLLA...
+      | 0xED 0x83 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE TYAG..HANGUL SYLLA...
+      | 0xED 0x84 0x00..0x93    #
+      | 0xED 0x84 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE TYAEG..HANGUL SYLL...
+      | 0xED 0x84 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE TEOG..HANGUL SYLLA...
+      | 0xED 0x85 0x00..0x8B    #
+      | 0xED 0x85 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE TEG..HANGUL SYLLAB...
+      | 0xED 0x85 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE TYEOG..HANGUL SYLL...
+      | 0xED 0x86 0x00..0x83    #
+      | 0xED 0x86 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE TYEG..HANGUL SYLLA...
+      | 0xED 0x86 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE TOG..HANGUL SYLLAB...
+      | 0xED 0x86 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE TWAG..HANGUL SYLLA...
+      | 0xED 0x87 0x00..0x97    #
+      | 0xED 0x87 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE TWAEG..HANGUL SYLL...
+      | 0xED 0x87 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE TOEG..HANGUL SYLLA...
+      | 0xED 0x88 0x00..0x8F    #
+      | 0xED 0x88 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE TYOG..HANGUL SYLLA...
+      | 0xED 0x88 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE TUG..HANGUL SYLLAB...
+      | 0xED 0x89 0x00..0x87    #
+      | 0xED 0x89 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE TWEOG..HANGUL SYLL...
+      | 0xED 0x89 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE TWEG..HANGUL SYLLA...
+      | 0xED 0x8A 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE TWIG..HANGUL SYLLA...
+      | 0xED 0x8A 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE TYUG..HANGUL SYLLA...
+      | 0xED 0x8A 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE TEUG..HANGUL SYLLA...
+      | 0xED 0x8B 0x00..0x93    #
+      | 0xED 0x8B 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE TYIG..HANGUL SYLLA...
+      | 0xED 0x8B 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE TIG..HANGUL SYLLAB...
+      | 0xED 0x8C 0x00..0x8B    #
+      | 0xED 0x8C 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE PAG..HANGUL SYLLAB...
+      | 0xED 0x8C 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE PAEG..HANGUL SYLLA...
+      | 0xED 0x8D 0x00..0x83    #
+      | 0xED 0x8D 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE PYAG..HANGUL SYLLA...
+      | 0xED 0x8D 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE PYAEG..HANGUL SYLL...
+      | 0xED 0x8D 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE PEOG..HANGUL SYLLA...
+      | 0xED 0x8E 0x00..0x97    #
+      | 0xED 0x8E 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE PEG..HANGUL SYLLAB...
+      | 0xED 0x8E 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE PYEOG..HANGUL SYLL...
+      | 0xED 0x8F 0x00..0x8F    #
+      | 0xED 0x8F 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE PYEG..HANGUL SYLLA...
+      | 0xED 0x8F 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE POG..HANGUL SYLLAB...
+      | 0xED 0x90 0x00..0x87    #
+      | 0xED 0x90 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE PWAG..HANGUL SYLLA...
+      | 0xED 0x90 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE PWAEG..HANGUL SYLL...
+      | 0xED 0x91 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE POEG..HANGUL SYLLA...
+      | 0xED 0x91 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE PYOG..HANGUL SYLLA...
+      | 0xED 0x91 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE PUG..HANGUL SYLLAB...
+      | 0xED 0x92 0x00..0x93    #
+      | 0xED 0x92 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE PWEOG..HANGUL SYLL...
+      | 0xED 0x92 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE PWEG..HANGUL SYLLA...
+      | 0xED 0x93 0x00..0x8B    #
+      | 0xED 0x93 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE PWIG..HANGUL SYLLA...
+      | 0xED 0x93 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE PYUG..HANGUL SYLLA...
+      | 0xED 0x94 0x00..0x83    #
+      | 0xED 0x94 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE PEUG..HANGUL SYLLA...
+      | 0xED 0x94 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE PYIG..HANGUL SYLLA...
+      | 0xED 0x94 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE PIG..HANGUL SYLLAB...
+      | 0xED 0x95 0x00..0x97    #
+      | 0xED 0x95 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE HAG..HANGUL SYLLAB...
+      | 0xED 0x95 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE HAEG..HANGUL SYLLA...
+      | 0xED 0x96 0x00..0x8F    #
+      | 0xED 0x96 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE HYAG..HANGUL SYLLA...
+      | 0xED 0x96 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE HYAEG..HANGUL SYLL...
+      | 0xED 0x97 0x00..0x87    #
+      | 0xED 0x97 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE HEOG..HANGUL SYLLA...
+      | 0xED 0x97 0xA5..0xBF    #Lo  [27] HANGUL SYLLABLE HEG..HANGUL SYLLAB...
+      | 0xED 0x98 0x81..0x9B    #Lo  [27] HANGUL SYLLABLE HYEOG..HANGUL SYLL...
+      | 0xED 0x98 0x9D..0xB7    #Lo  [27] HANGUL SYLLABLE HYEG..HANGUL SYLLA...
+      | 0xED 0x98 0xB9..0xFF    #Lo  [27] HANGUL SYLLABLE HOG..HANGUL SYLLAB...
+      | 0xED 0x99 0x00..0x93    #
+      | 0xED 0x99 0x95..0xAF    #Lo  [27] HANGUL SYLLABLE HWAG..HANGUL SYLLA...
+      | 0xED 0x99 0xB1..0xFF    #Lo  [27] HANGUL SYLLABLE HWAEG..HANGUL SYLL...
+      | 0xED 0x9A 0x00..0x8B    #
+      | 0xED 0x9A 0x8D..0xA7    #Lo  [27] HANGUL SYLLABLE HOEG..HANGUL SYLLA...
+      | 0xED 0x9A 0xA9..0xFF    #Lo  [27] HANGUL SYLLABLE HYOG..HANGUL SYLLA...
+      | 0xED 0x9B 0x00..0x83    #
+      | 0xED 0x9B 0x85..0x9F    #Lo  [27] HANGUL SYLLABLE HUG..HANGUL SYLLAB...
+      | 0xED 0x9B 0xA1..0xBB    #Lo  [27] HANGUL SYLLABLE HWEOG..HANGUL SYLL...
+      | 0xED 0x9B 0xBD..0xFF    #Lo  [27] HANGUL SYLLABLE HWEG..HANGUL SYLLA...
+      | 0xED 0x9C 0x00..0x97    #
+      | 0xED 0x9C 0x99..0xB3    #Lo  [27] HANGUL SYLLABLE HWIG..HANGUL SYLLA...
+      | 0xED 0x9C 0xB5..0xFF    #Lo  [27] HANGUL SYLLABLE HYUG..HANGUL SYLLA...
+      | 0xED 0x9D 0x00..0x8F    #
+      | 0xED 0x9D 0x91..0xAB    #Lo  [27] HANGUL SYLLABLE HEUG..HANGUL SYLLA...
+      | 0xED 0x9D 0xAD..0xFF    #Lo  [27] HANGUL SYLLABLE HYIG..HANGUL SYLLA...
+      | 0xED 0x9E 0x00..0x87    #
+      | 0xED 0x9E 0x89..0xA3    #Lo  [27] HANGUL SYLLABLE HIG..HANGUL SYLLAB...
+      ;
+
+    E_Base = 
+        0xE2 0x98 0x9D          #So       WHITE UP POINTING INDEX
+      | 0xE2 0x9B 0xB9          #So       PERSON WITH BALL
+      | 0xE2 0x9C 0x8A..0x8D    #So   [4] RAISED FIST..WRITING HAND
+      | 0xF0 0x9F 0x8E 0x85     #So       FATHER CHRISTMAS
+      | 0xF0 0x9F 0x8F 0x83..0x84  #So   [2] RUNNER..SURFER
+      | 0xF0 0x9F 0x8F 0x8A..0x8B  #So   [2] SWIMMER..WEIGHT LIFTER
+      | 0xF0 0x9F 0x91 0x82..0x83  #So   [2] EAR..NOSE
+      | 0xF0 0x9F 0x91 0x86..0x90  #So  [11] WHITE UP POINTING BACKHAND INDE...
+      | 0xF0 0x9F 0x91 0xAE     #So       POLICE OFFICER
+      | 0xF0 0x9F 0x91 0xB0..0xB8  #So   [9] BRIDE WITH VEIL..PRINCESS
+      | 0xF0 0x9F 0x91 0xBC     #So       BABY ANGEL
+      | 0xF0 0x9F 0x92 0x81..0x83  #So   [3] INFORMATION DESK PERSON..DANCER
+      | 0xF0 0x9F 0x92 0x85..0x87  #So   [3] NAIL POLISH..HAIRCUT
+      | 0xF0 0x9F 0x92 0xAA     #So       FLEXED BICEPS
+      | 0xF0 0x9F 0x95 0xB5     #So       SLEUTH OR SPY
+      | 0xF0 0x9F 0x95 0xBA     #So       MAN DANCING
+      | 0xF0 0x9F 0x96 0x90     #So       RAISED HAND WITH FINGERS SPLAYED
+      | 0xF0 0x9F 0x96 0x95..0x96  #So   [2] REVERSED HAND WITH MIDDLE FINGE...
+      | 0xF0 0x9F 0x99 0x85..0x87  #So   [3] FACE WITH NO GOOD GESTURE..PERS...
+      | 0xF0 0x9F 0x99 0x8B..0x8F  #So   [5] HAPPY PERSON RAISING ONE HAND.....
+      | 0xF0 0x9F 0x9A 0xA3     #So       ROWBOAT
+      | 0xF0 0x9F 0x9A 0xB4..0xB6  #So   [3] BICYCLIST..PEDESTRIAN
+      | 0xF0 0x9F 0x9B 0x80     #So       BATH
+      | 0xF0 0x9F 0xA4 0x98..0x9E  #So   [7] SIGN OF THE HORNS..HAND WITH IN...
+      | 0xF0 0x9F 0xA4 0xA6     #So       FACE PALM
+      | 0xF0 0x9F 0xA4 0xB0     #So       PREGNANT WOMAN
+      | 0xF0 0x9F 0xA4 0xB3..0xB9  #So   [7] SELFIE..JUGGLING
+      | 0xF0 0x9F 0xA4 0xBC..0xBE  #So   [3] WRESTLERS..HANDBALL
+      ;
+
+    E_Modifier = 
+        0xF0 0x9F 0x8F 0xBB..0xBF  #Sk   [5] EMOJI MODIFIER FITZPATRICK TYPE...
+      ;
+
+    ZWJ = 
+        0xE2 0x80 0x8D          #Cf       ZERO WIDTH JOINER
+      ;
+
+    Glue_After_Zwj = 
+        0xE2 0x9D 0xA4          #So       HEAVY BLACK HEART
+      | 0xF0 0x9F 0x92 0x8B     #So       KISS MARK
+      | 0xF0 0x9F 0x97 0xA8     #So       LEFT SPEECH BUBBLE
+      ;
+
+    E_Base_GAZ = 
+        0xF0 0x9F 0x91 0xA6..0xA9  #So   [4] BOY..WOMAN
+      ;
+
+}%%
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/tables.go b/vendor/github.com/apparentlymart/go-textseg/textseg/tables.go
new file mode 100644
index 000000000..fab7e8429
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/tables.go
@@ -0,0 +1,5700 @@
+// Generated by running
+//      maketables --url=http://www.unicode.org/Public/9.0.0/ucd/auxiliary/
+// DO NOT EDIT
+
+package textseg
+
+import (
+	"unicode"
+)
+
+var _GraphemeCR = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xd, Hi: 0xd, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _GraphemeControl = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x0, Hi: 0x9, Stride: 0x1},
+		unicode.Range16{Lo: 0xb, Hi: 0xc, Stride: 0x1},
+		unicode.Range16{Lo: 0xe, Hi: 0x1f, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f, Hi: 0x9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xad, Hi: 0xad, Stride: 0x1},
+		unicode.Range16{Lo: 0x61c, Hi: 0x61c, Stride: 0x1},
+		unicode.Range16{Lo: 0x180e, Hi: 0x180e, Stride: 0x1},
+		unicode.Range16{Lo: 0x200b, Hi: 0x200b, Stride: 0x1},
+		unicode.Range16{Lo: 0x200e, Hi: 0x200f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2028, Hi: 0x2028, Stride: 0x1},
+		unicode.Range16{Lo: 0x2029, Hi: 0x2029, Stride: 0x1},
+		unicode.Range16{Lo: 0x202a, Hi: 0x202e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2060, Hi: 0x2064, Stride: 0x1},
+		unicode.Range16{Lo: 0x2065, Hi: 0x2065, Stride: 0x1},
+		unicode.Range16{Lo: 0x2066, Hi: 0x206f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd800, Hi: 0xdfff, Stride: 0x1},
+		unicode.Range16{Lo: 0xfeff, Hi: 0xfeff, Stride: 0x1},
+		unicode.Range16{Lo: 0xfff0, Hi: 0xfff8, Stride: 0x1},
+		unicode.Range16{Lo: 0xfff9, Hi: 0xfffb, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1bca0, Hi: 0x1bca3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d173, Hi: 0x1d17a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0000, Hi: 0xe0000, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0001, Hi: 0xe0001, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0002, Hi: 0xe001f, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0080, Hi: 0xe00ff, Stride: 0x1},
+		unicode.Range32{Lo: 0xe01f0, Hi: 0xe0fff, Stride: 0x1},
+	},
+	LatinOffset: 5,
+}
+
+var _GraphemeE_Base = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x261d, Hi: 0x261d, Stride: 0x1},
+		unicode.Range16{Lo: 0x26f9, Hi: 0x26f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x270a, Hi: 0x270d, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f385, Hi: 0x1f385, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f3c3, Hi: 0x1f3c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f3ca, Hi: 0x1f3cb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f442, Hi: 0x1f443, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f446, Hi: 0x1f450, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f46e, Hi: 0x1f46e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f470, Hi: 0x1f478, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f47c, Hi: 0x1f47c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f481, Hi: 0x1f483, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f485, Hi: 0x1f487, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f4aa, Hi: 0x1f4aa, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f575, Hi: 0x1f575, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f57a, Hi: 0x1f57a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f590, Hi: 0x1f590, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f595, Hi: 0x1f596, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f645, Hi: 0x1f647, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f64b, Hi: 0x1f64f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6a3, Hi: 0x1f6a3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6b4, Hi: 0x1f6b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6c0, Hi: 0x1f6c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f918, Hi: 0x1f91e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f926, Hi: 0x1f926, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f930, Hi: 0x1f930, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f933, Hi: 0x1f939, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f93c, Hi: 0x1f93e, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeE_Base_GAZ = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f466, Hi: 0x1f469, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeE_Modifier = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f3fb, Hi: 0x1f3ff, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeExtend = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x300, Hi: 0x36f, Stride: 0x1},
+		unicode.Range16{Lo: 0x483, Hi: 0x487, Stride: 0x1},
+		unicode.Range16{Lo: 0x488, Hi: 0x489, Stride: 0x1},
+		unicode.Range16{Lo: 0x591, Hi: 0x5bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x5bf, Hi: 0x5bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c1, Hi: 0x5c2, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c4, Hi: 0x5c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c7, Hi: 0x5c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x610, Hi: 0x61a, Stride: 0x1},
+		unicode.Range16{Lo: 0x64b, Hi: 0x65f, Stride: 0x1},
+		unicode.Range16{Lo: 0x670, Hi: 0x670, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d6, Hi: 0x6dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x6df, Hi: 0x6e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x6e7, Hi: 0x6e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ea, Hi: 0x6ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x711, Hi: 0x711, Stride: 0x1},
+		unicode.Range16{Lo: 0x730, Hi: 0x74a, Stride: 0x1},
+		unicode.Range16{Lo: 0x7a6, Hi: 0x7b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x7eb, Hi: 0x7f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x816, Hi: 0x819, Stride: 0x1},
+		unicode.Range16{Lo: 0x81b, Hi: 0x823, Stride: 0x1},
+		unicode.Range16{Lo: 0x825, Hi: 0x827, Stride: 0x1},
+		unicode.Range16{Lo: 0x829, Hi: 0x82d, Stride: 0x1},
+		unicode.Range16{Lo: 0x859, Hi: 0x85b, Stride: 0x1},
+		unicode.Range16{Lo: 0x8d4, Hi: 0x8e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e3, Hi: 0x902, Stride: 0x1},
+		unicode.Range16{Lo: 0x93a, Hi: 0x93a, Stride: 0x1},
+		unicode.Range16{Lo: 0x93c, Hi: 0x93c, Stride: 0x1},
+		unicode.Range16{Lo: 0x941, Hi: 0x948, Stride: 0x1},
+		unicode.Range16{Lo: 0x94d, Hi: 0x94d, Stride: 0x1},
+		unicode.Range16{Lo: 0x951, Hi: 0x957, Stride: 0x1},
+		unicode.Range16{Lo: 0x962, Hi: 0x963, Stride: 0x1},
+		unicode.Range16{Lo: 0x981, Hi: 0x981, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bc, Hi: 0x9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0x9be, Hi: 0x9be, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c1, Hi: 0x9c4, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cd, Hi: 0x9cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9d7, Hi: 0x9d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x9e2, Hi: 0x9e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa01, Hi: 0xa02, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3c, Hi: 0xa3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa41, Hi: 0xa42, Stride: 0x1},
+		unicode.Range16{Lo: 0xa47, Hi: 0xa48, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4b, Hi: 0xa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa51, Hi: 0xa51, Stride: 0x1},
+		unicode.Range16{Lo: 0xa70, Hi: 0xa71, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75, Hi: 0xa75, Stride: 0x1},
+		unicode.Range16{Lo: 0xa81, Hi: 0xa82, Stride: 0x1},
+		unicode.Range16{Lo: 0xabc, Hi: 0xabc, Stride: 0x1},
+		unicode.Range16{Lo: 0xac1, Hi: 0xac5, Stride: 0x1},
+		unicode.Range16{Lo: 0xac7, Hi: 0xac8, Stride: 0x1},
+		unicode.Range16{Lo: 0xacd, Hi: 0xacd, Stride: 0x1},
+		unicode.Range16{Lo: 0xae2, Hi: 0xae3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb01, Hi: 0xb01, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3c, Hi: 0xb3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3e, Hi: 0xb3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3f, Hi: 0xb3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb41, Hi: 0xb44, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4d, Hi: 0xb4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb56, Hi: 0xb56, Stride: 0x1},
+		unicode.Range16{Lo: 0xb57, Hi: 0xb57, Stride: 0x1},
+		unicode.Range16{Lo: 0xb62, Hi: 0xb63, Stride: 0x1},
+		unicode.Range16{Lo: 0xb82, Hi: 0xb82, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbe, Hi: 0xbbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc0, Hi: 0xbc0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcd, Hi: 0xbcd, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd7, Hi: 0xbd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc00, Hi: 0xc00, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3e, Hi: 0xc40, Stride: 0x1},
+		unicode.Range16{Lo: 0xc46, Hi: 0xc48, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4a, Hi: 0xc4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xc55, Hi: 0xc56, Stride: 0x1},
+		unicode.Range16{Lo: 0xc62, Hi: 0xc63, Stride: 0x1},
+		unicode.Range16{Lo: 0xc81, Hi: 0xc81, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbc, Hi: 0xcbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbf, Hi: 0xcbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc2, Hi: 0xcc2, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc6, Hi: 0xcc6, Stride: 0x1},
+		unicode.Range16{Lo: 0xccc, Hi: 0xccd, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd5, Hi: 0xcd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xce2, Hi: 0xce3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd01, Hi: 0xd01, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3e, Hi: 0xd3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xd41, Hi: 0xd44, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4d, Hi: 0xd4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xd57, Hi: 0xd57, Stride: 0x1},
+		unicode.Range16{Lo: 0xd62, Hi: 0xd63, Stride: 0x1},
+		unicode.Range16{Lo: 0xdca, Hi: 0xdca, Stride: 0x1},
+		unicode.Range16{Lo: 0xdcf, Hi: 0xdcf, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd2, Hi: 0xdd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd6, Hi: 0xdd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xddf, Hi: 0xddf, Stride: 0x1},
+		unicode.Range16{Lo: 0xe31, Hi: 0xe31, Stride: 0x1},
+		unicode.Range16{Lo: 0xe34, Hi: 0xe3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xe47, Hi: 0xe4e, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb1, Hi: 0xeb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb4, Hi: 0xeb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xebb, Hi: 0xebc, Stride: 0x1},
+		unicode.Range16{Lo: 0xec8, Hi: 0xecd, Stride: 0x1},
+		unicode.Range16{Lo: 0xf18, Hi: 0xf19, Stride: 0x1},
+		unicode.Range16{Lo: 0xf35, Hi: 0xf35, Stride: 0x1},
+		unicode.Range16{Lo: 0xf37, Hi: 0xf37, Stride: 0x1},
+		unicode.Range16{Lo: 0xf39, Hi: 0xf39, Stride: 0x1},
+		unicode.Range16{Lo: 0xf71, Hi: 0xf7e, Stride: 0x1},
+		unicode.Range16{Lo: 0xf80, Hi: 0xf84, Stride: 0x1},
+		unicode.Range16{Lo: 0xf86, Hi: 0xf87, Stride: 0x1},
+		unicode.Range16{Lo: 0xf8d, Hi: 0xf97, Stride: 0x1},
+		unicode.Range16{Lo: 0xf99, Hi: 0xfbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xfc6, Hi: 0xfc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x102d, Hi: 0x1030, Stride: 0x1},
+		unicode.Range16{Lo: 0x1032, Hi: 0x1037, Stride: 0x1},
+		unicode.Range16{Lo: 0x1039, Hi: 0x103a, Stride: 0x1},
+		unicode.Range16{Lo: 0x103d, Hi: 0x103e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1058, Hi: 0x1059, Stride: 0x1},
+		unicode.Range16{Lo: 0x105e, Hi: 0x1060, Stride: 0x1},
+		unicode.Range16{Lo: 0x1071, Hi: 0x1074, Stride: 0x1},
+		unicode.Range16{Lo: 0x1082, Hi: 0x1082, Stride: 0x1},
+		unicode.Range16{Lo: 0x1085, Hi: 0x1086, Stride: 0x1},
+		unicode.Range16{Lo: 0x108d, Hi: 0x108d, Stride: 0x1},
+		unicode.Range16{Lo: 0x109d, Hi: 0x109d, Stride: 0x1},
+		unicode.Range16{Lo: 0x135d, Hi: 0x135f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1712, Hi: 0x1714, Stride: 0x1},
+		unicode.Range16{Lo: 0x1732, Hi: 0x1734, Stride: 0x1},
+		unicode.Range16{Lo: 0x1752, Hi: 0x1753, Stride: 0x1},
+		unicode.Range16{Lo: 0x1772, Hi: 0x1773, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b4, Hi: 0x17b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b7, Hi: 0x17bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c6, Hi: 0x17c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c9, Hi: 0x17d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x17dd, Hi: 0x17dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x180b, Hi: 0x180d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1885, Hi: 0x1886, Stride: 0x1},
+		unicode.Range16{Lo: 0x18a9, Hi: 0x18a9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1920, Hi: 0x1922, Stride: 0x1},
+		unicode.Range16{Lo: 0x1927, Hi: 0x1928, Stride: 0x1},
+		unicode.Range16{Lo: 0x1932, Hi: 0x1932, Stride: 0x1},
+		unicode.Range16{Lo: 0x1939, Hi: 0x193b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a17, Hi: 0x1a18, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a1b, Hi: 0x1a1b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a56, Hi: 0x1a56, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a58, Hi: 0x1a5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a60, Hi: 0x1a60, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a62, Hi: 0x1a62, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a65, Hi: 0x1a6c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a73, Hi: 0x1a7c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a7f, Hi: 0x1a7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ab0, Hi: 0x1abd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1abe, Hi: 0x1abe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b00, Hi: 0x1b03, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b34, Hi: 0x1b34, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b36, Hi: 0x1b3a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3c, Hi: 0x1b3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b42, Hi: 0x1b42, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b6b, Hi: 0x1b73, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b80, Hi: 0x1b81, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba2, Hi: 0x1ba5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba8, Hi: 0x1ba9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bab, Hi: 0x1bad, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be6, Hi: 0x1be6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be8, Hi: 0x1be9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bed, Hi: 0x1bed, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bef, Hi: 0x1bf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c2c, Hi: 0x1c33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c36, Hi: 0x1c37, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd0, Hi: 0x1cd2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd4, Hi: 0x1ce0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce2, Hi: 0x1ce8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ced, Hi: 0x1ced, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf4, Hi: 0x1cf4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf8, Hi: 0x1cf9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dc0, Hi: 0x1df5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dfb, Hi: 0x1dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x200c, Hi: 0x200c, Stride: 0x1},
+		unicode.Range16{Lo: 0x20d0, Hi: 0x20dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x20dd, Hi: 0x20e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e1, Hi: 0x20e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e2, Hi: 0x20e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e5, Hi: 0x20f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cef, Hi: 0x2cf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d7f, Hi: 0x2d7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2de0, Hi: 0x2dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x302a, Hi: 0x302d, Stride: 0x1},
+		unicode.Range16{Lo: 0x302e, Hi: 0x302f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3099, Hi: 0x309a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66f, Hi: 0xa66f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa670, Hi: 0xa672, Stride: 0x1},
+		unicode.Range16{Lo: 0xa674, Hi: 0xa67d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69e, Hi: 0xa69f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6f0, Hi: 0xa6f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa802, Hi: 0xa802, Stride: 0x1},
+		unicode.Range16{Lo: 0xa806, Hi: 0xa806, Stride: 0x1},
+		unicode.Range16{Lo: 0xa80b, Hi: 0xa80b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa825, Hi: 0xa826, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8c4, Hi: 0xa8c5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8e0, Hi: 0xa8f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa926, Hi: 0xa92d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa947, Hi: 0xa951, Stride: 0x1},
+		unicode.Range16{Lo: 0xa980, Hi: 0xa982, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b3, Hi: 0xa9b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b6, Hi: 0xa9b9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bc, Hi: 0xa9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e5, Hi: 0xa9e5, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa29, Hi: 0xaa2e, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa31, Hi: 0xaa32, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa35, Hi: 0xaa36, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa43, Hi: 0xaa43, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4c, Hi: 0xaa4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7c, Hi: 0xaa7c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab0, Hi: 0xaab0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab2, Hi: 0xaab4, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab7, Hi: 0xaab8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaabe, Hi: 0xaabf, Stride: 0x1},
+		unicode.Range16{Lo: 0xaac1, Hi: 0xaac1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaec, Hi: 0xaaed, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf6, Hi: 0xaaf6, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe5, Hi: 0xabe5, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe8, Hi: 0xabe8, Stride: 0x1},
+		unicode.Range16{Lo: 0xabed, Hi: 0xabed, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1e, Hi: 0xfb1e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe00, Hi: 0xfe0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe20, Hi: 0xfe2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff9e, Hi: 0xff9f, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x101fd, Hi: 0x101fd, Stride: 0x1},
+		unicode.Range32{Lo: 0x102e0, Hi: 0x102e0, Stride: 0x1},
+		unicode.Range32{Lo: 0x10376, Hi: 0x1037a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a01, Hi: 0x10a03, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a05, Hi: 0x10a06, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a0c, Hi: 0x10a0f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a38, Hi: 0x10a3a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a3f, Hi: 0x10a3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ae5, Hi: 0x10ae6, Stride: 0x1},
+		unicode.Range32{Lo: 0x11001, Hi: 0x11001, Stride: 0x1},
+		unicode.Range32{Lo: 0x11038, Hi: 0x11046, Stride: 0x1},
+		unicode.Range32{Lo: 0x1107f, Hi: 0x11081, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b3, Hi: 0x110b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b9, Hi: 0x110ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x11100, Hi: 0x11102, Stride: 0x1},
+		unicode.Range32{Lo: 0x11127, Hi: 0x1112b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112d, Hi: 0x11134, Stride: 0x1},
+		unicode.Range32{Lo: 0x11173, Hi: 0x11173, Stride: 0x1},
+		unicode.Range32{Lo: 0x11180, Hi: 0x11181, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b6, Hi: 0x111be, Stride: 0x1},
+		unicode.Range32{Lo: 0x111ca, Hi: 0x111cc, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122f, Hi: 0x11231, Stride: 0x1},
+		unicode.Range32{Lo: 0x11234, Hi: 0x11234, Stride: 0x1},
+		unicode.Range32{Lo: 0x11236, Hi: 0x11237, Stride: 0x1},
+		unicode.Range32{Lo: 0x1123e, Hi: 0x1123e, Stride: 0x1},
+		unicode.Range32{Lo: 0x112df, Hi: 0x112df, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e3, Hi: 0x112ea, Stride: 0x1},
+		unicode.Range32{Lo: 0x11300, Hi: 0x11301, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133c, Hi: 0x1133c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133e, Hi: 0x1133e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11340, Hi: 0x11340, Stride: 0x1},
+		unicode.Range32{Lo: 0x11357, Hi: 0x11357, Stride: 0x1},
+		unicode.Range32{Lo: 0x11366, Hi: 0x1136c, Stride: 0x1},
+		unicode.Range32{Lo: 0x11370, Hi: 0x11374, Stride: 0x1},
+		unicode.Range32{Lo: 0x11438, Hi: 0x1143f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11442, Hi: 0x11444, Stride: 0x1},
+		unicode.Range32{Lo: 0x11446, Hi: 0x11446, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b0, Hi: 0x114b0, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b3, Hi: 0x114b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x114ba, Hi: 0x114ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bd, Hi: 0x114bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bf, Hi: 0x114c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c2, Hi: 0x114c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x115af, Hi: 0x115af, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b2, Hi: 0x115b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bc, Hi: 0x115bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bf, Hi: 0x115c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x115dc, Hi: 0x115dd, Stride: 0x1},
+		unicode.Range32{Lo: 0x11633, Hi: 0x1163a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163d, Hi: 0x1163d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163f, Hi: 0x11640, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ab, Hi: 0x116ab, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ad, Hi: 0x116ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b0, Hi: 0x116b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b7, Hi: 0x116b7, Stride: 0x1},
+		unicode.Range32{Lo: 0x1171d, Hi: 0x1171f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11722, Hi: 0x11725, Stride: 0x1},
+		unicode.Range32{Lo: 0x11727, Hi: 0x1172b, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c30, Hi: 0x11c36, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c38, Hi: 0x11c3d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3f, Hi: 0x11c3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c92, Hi: 0x11ca7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11caa, Hi: 0x11cb0, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb2, Hi: 0x11cb3, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb5, Hi: 0x11cb6, Stride: 0x1},
+		unicode.Range32{Lo: 0x16af0, Hi: 0x16af4, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b30, Hi: 0x16b36, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f8f, Hi: 0x16f92, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc9d, Hi: 0x1bc9e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d165, Hi: 0x1d165, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d167, Hi: 0x1d169, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d16e, Hi: 0x1d172, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d17b, Hi: 0x1d182, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d185, Hi: 0x1d18b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d1aa, Hi: 0x1d1ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d242, Hi: 0x1d244, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da00, Hi: 0x1da36, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da3b, Hi: 0x1da6c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da75, Hi: 0x1da75, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da84, Hi: 0x1da84, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da9b, Hi: 0x1da9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1daa1, Hi: 0x1daaf, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e000, Hi: 0x1e006, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e008, Hi: 0x1e018, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e01b, Hi: 0x1e021, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e023, Hi: 0x1e024, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e026, Hi: 0x1e02a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e8d0, Hi: 0x1e8d6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e944, Hi: 0x1e94a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0020, Hi: 0xe007f, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0100, Hi: 0xe01ef, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeGlue_After_Zwj = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2764, Hi: 0x2764, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f48b, Hi: 0x1f48b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f5e8, Hi: 0x1f5e8, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeL = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x1100, Hi: 0x115f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa960, Hi: 0xa97c, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeLF = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xa, Hi: 0xa, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _GraphemeLV = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xac00, Hi: 0xac00, Stride: 0x1},
+		unicode.Range16{Lo: 0xac1c, Hi: 0xac1c, Stride: 0x1},
+		unicode.Range16{Lo: 0xac38, Hi: 0xac38, Stride: 0x1},
+		unicode.Range16{Lo: 0xac54, Hi: 0xac54, Stride: 0x1},
+		unicode.Range16{Lo: 0xac70, Hi: 0xac70, Stride: 0x1},
+		unicode.Range16{Lo: 0xac8c, Hi: 0xac8c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaca8, Hi: 0xaca8, Stride: 0x1},
+		unicode.Range16{Lo: 0xacc4, Hi: 0xacc4, Stride: 0x1},
+		unicode.Range16{Lo: 0xace0, Hi: 0xace0, Stride: 0x1},
+		unicode.Range16{Lo: 0xacfc, Hi: 0xacfc, Stride: 0x1},
+		unicode.Range16{Lo: 0xad18, Hi: 0xad18, Stride: 0x1},
+		unicode.Range16{Lo: 0xad34, Hi: 0xad34, Stride: 0x1},
+		unicode.Range16{Lo: 0xad50, Hi: 0xad50, Stride: 0x1},
+		unicode.Range16{Lo: 0xad6c, Hi: 0xad6c, Stride: 0x1},
+		unicode.Range16{Lo: 0xad88, Hi: 0xad88, Stride: 0x1},
+		unicode.Range16{Lo: 0xada4, Hi: 0xada4, Stride: 0x1},
+		unicode.Range16{Lo: 0xadc0, Hi: 0xadc0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaddc, Hi: 0xaddc, Stride: 0x1},
+		unicode.Range16{Lo: 0xadf8, Hi: 0xadf8, Stride: 0x1},
+		unicode.Range16{Lo: 0xae14, Hi: 0xae14, Stride: 0x1},
+		unicode.Range16{Lo: 0xae30, Hi: 0xae30, Stride: 0x1},
+		unicode.Range16{Lo: 0xae4c, Hi: 0xae4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xae68, Hi: 0xae68, Stride: 0x1},
+		unicode.Range16{Lo: 0xae84, Hi: 0xae84, Stride: 0x1},
+		unicode.Range16{Lo: 0xaea0, Hi: 0xaea0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaebc, Hi: 0xaebc, Stride: 0x1},
+		unicode.Range16{Lo: 0xaed8, Hi: 0xaed8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaef4, Hi: 0xaef4, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf10, Hi: 0xaf10, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf2c, Hi: 0xaf2c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf48, Hi: 0xaf48, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf64, Hi: 0xaf64, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf80, Hi: 0xaf80, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf9c, Hi: 0xaf9c, Stride: 0x1},
+		unicode.Range16{Lo: 0xafb8, Hi: 0xafb8, Stride: 0x1},
+		unicode.Range16{Lo: 0xafd4, Hi: 0xafd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xaff0, Hi: 0xaff0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb00c, Hi: 0xb00c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb028, Hi: 0xb028, Stride: 0x1},
+		unicode.Range16{Lo: 0xb044, Hi: 0xb044, Stride: 0x1},
+		unicode.Range16{Lo: 0xb060, Hi: 0xb060, Stride: 0x1},
+		unicode.Range16{Lo: 0xb07c, Hi: 0xb07c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb098, Hi: 0xb098, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0b4, Hi: 0xb0b4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0d0, Hi: 0xb0d0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0ec, Hi: 0xb0ec, Stride: 0x1},
+		unicode.Range16{Lo: 0xb108, Hi: 0xb108, Stride: 0x1},
+		unicode.Range16{Lo: 0xb124, Hi: 0xb124, Stride: 0x1},
+		unicode.Range16{Lo: 0xb140, Hi: 0xb140, Stride: 0x1},
+		unicode.Range16{Lo: 0xb15c, Hi: 0xb15c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb178, Hi: 0xb178, Stride: 0x1},
+		unicode.Range16{Lo: 0xb194, Hi: 0xb194, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1b0, Hi: 0xb1b0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1cc, Hi: 0xb1cc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1e8, Hi: 0xb1e8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb204, Hi: 0xb204, Stride: 0x1},
+		unicode.Range16{Lo: 0xb220, Hi: 0xb220, Stride: 0x1},
+		unicode.Range16{Lo: 0xb23c, Hi: 0xb23c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb258, Hi: 0xb258, Stride: 0x1},
+		unicode.Range16{Lo: 0xb274, Hi: 0xb274, Stride: 0x1},
+		unicode.Range16{Lo: 0xb290, Hi: 0xb290, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2ac, Hi: 0xb2ac, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2c8, Hi: 0xb2c8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2e4, Hi: 0xb2e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb300, Hi: 0xb300, Stride: 0x1},
+		unicode.Range16{Lo: 0xb31c, Hi: 0xb31c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb338, Hi: 0xb338, Stride: 0x1},
+		unicode.Range16{Lo: 0xb354, Hi: 0xb354, Stride: 0x1},
+		unicode.Range16{Lo: 0xb370, Hi: 0xb370, Stride: 0x1},
+		unicode.Range16{Lo: 0xb38c, Hi: 0xb38c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3a8, Hi: 0xb3a8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3c4, Hi: 0xb3c4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3e0, Hi: 0xb3e0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3fc, Hi: 0xb3fc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb418, Hi: 0xb418, Stride: 0x1},
+		unicode.Range16{Lo: 0xb434, Hi: 0xb434, Stride: 0x1},
+		unicode.Range16{Lo: 0xb450, Hi: 0xb450, Stride: 0x1},
+		unicode.Range16{Lo: 0xb46c, Hi: 0xb46c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb488, Hi: 0xb488, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4a4, Hi: 0xb4a4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4c0, Hi: 0xb4c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4dc, Hi: 0xb4dc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4f8, Hi: 0xb4f8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb514, Hi: 0xb514, Stride: 0x1},
+		unicode.Range16{Lo: 0xb530, Hi: 0xb530, Stride: 0x1},
+		unicode.Range16{Lo: 0xb54c, Hi: 0xb54c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb568, Hi: 0xb568, Stride: 0x1},
+		unicode.Range16{Lo: 0xb584, Hi: 0xb584, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5a0, Hi: 0xb5a0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5bc, Hi: 0xb5bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5d8, Hi: 0xb5d8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5f4, Hi: 0xb5f4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb610, Hi: 0xb610, Stride: 0x1},
+		unicode.Range16{Lo: 0xb62c, Hi: 0xb62c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb648, Hi: 0xb648, Stride: 0x1},
+		unicode.Range16{Lo: 0xb664, Hi: 0xb664, Stride: 0x1},
+		unicode.Range16{Lo: 0xb680, Hi: 0xb680, Stride: 0x1},
+		unicode.Range16{Lo: 0xb69c, Hi: 0xb69c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6b8, Hi: 0xb6b8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6d4, Hi: 0xb6d4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6f0, Hi: 0xb6f0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb70c, Hi: 0xb70c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb728, Hi: 0xb728, Stride: 0x1},
+		unicode.Range16{Lo: 0xb744, Hi: 0xb744, Stride: 0x1},
+		unicode.Range16{Lo: 0xb760, Hi: 0xb760, Stride: 0x1},
+		unicode.Range16{Lo: 0xb77c, Hi: 0xb77c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb798, Hi: 0xb798, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7b4, Hi: 0xb7b4, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7d0, Hi: 0xb7d0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7ec, Hi: 0xb7ec, Stride: 0x1},
+		unicode.Range16{Lo: 0xb808, Hi: 0xb808, Stride: 0x1},
+		unicode.Range16{Lo: 0xb824, Hi: 0xb824, Stride: 0x1},
+		unicode.Range16{Lo: 0xb840, Hi: 0xb840, Stride: 0x1},
+		unicode.Range16{Lo: 0xb85c, Hi: 0xb85c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb878, Hi: 0xb878, Stride: 0x1},
+		unicode.Range16{Lo: 0xb894, Hi: 0xb894, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8b0, Hi: 0xb8b0, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8cc, Hi: 0xb8cc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8e8, Hi: 0xb8e8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb904, Hi: 0xb904, Stride: 0x1},
+		unicode.Range16{Lo: 0xb920, Hi: 0xb920, Stride: 0x1},
+		unicode.Range16{Lo: 0xb93c, Hi: 0xb93c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb958, Hi: 0xb958, Stride: 0x1},
+		unicode.Range16{Lo: 0xb974, Hi: 0xb974, Stride: 0x1},
+		unicode.Range16{Lo: 0xb990, Hi: 0xb990, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9ac, Hi: 0xb9ac, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9c8, Hi: 0xb9c8, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9e4, Hi: 0xb9e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xba00, Hi: 0xba00, Stride: 0x1},
+		unicode.Range16{Lo: 0xba1c, Hi: 0xba1c, Stride: 0x1},
+		unicode.Range16{Lo: 0xba38, Hi: 0xba38, Stride: 0x1},
+		unicode.Range16{Lo: 0xba54, Hi: 0xba54, Stride: 0x1},
+		unicode.Range16{Lo: 0xba70, Hi: 0xba70, Stride: 0x1},
+		unicode.Range16{Lo: 0xba8c, Hi: 0xba8c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbaa8, Hi: 0xbaa8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbac4, Hi: 0xbac4, Stride: 0x1},
+		unicode.Range16{Lo: 0xbae0, Hi: 0xbae0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbafc, Hi: 0xbafc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb18, Hi: 0xbb18, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb34, Hi: 0xbb34, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb50, Hi: 0xbb50, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb6c, Hi: 0xbb6c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb88, Hi: 0xbb88, Stride: 0x1},
+		unicode.Range16{Lo: 0xbba4, Hi: 0xbba4, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbc0, Hi: 0xbbc0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbdc, Hi: 0xbbdc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbf8, Hi: 0xbbf8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc14, Hi: 0xbc14, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc30, Hi: 0xbc30, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc4c, Hi: 0xbc4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc68, Hi: 0xbc68, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc84, Hi: 0xbc84, Stride: 0x1},
+		unicode.Range16{Lo: 0xbca0, Hi: 0xbca0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcbc, Hi: 0xbcbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcd8, Hi: 0xbcd8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcf4, Hi: 0xbcf4, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd10, Hi: 0xbd10, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd2c, Hi: 0xbd2c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd48, Hi: 0xbd48, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd64, Hi: 0xbd64, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd80, Hi: 0xbd80, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd9c, Hi: 0xbd9c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdb8, Hi: 0xbdb8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdd4, Hi: 0xbdd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdf0, Hi: 0xbdf0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe0c, Hi: 0xbe0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe28, Hi: 0xbe28, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe44, Hi: 0xbe44, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe60, Hi: 0xbe60, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe7c, Hi: 0xbe7c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe98, Hi: 0xbe98, Stride: 0x1},
+		unicode.Range16{Lo: 0xbeb4, Hi: 0xbeb4, Stride: 0x1},
+		unicode.Range16{Lo: 0xbed0, Hi: 0xbed0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbeec, Hi: 0xbeec, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf08, Hi: 0xbf08, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf24, Hi: 0xbf24, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf40, Hi: 0xbf40, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf5c, Hi: 0xbf5c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf78, Hi: 0xbf78, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf94, Hi: 0xbf94, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfb0, Hi: 0xbfb0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfcc, Hi: 0xbfcc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfe8, Hi: 0xbfe8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc004, Hi: 0xc004, Stride: 0x1},
+		unicode.Range16{Lo: 0xc020, Hi: 0xc020, Stride: 0x1},
+		unicode.Range16{Lo: 0xc03c, Hi: 0xc03c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc058, Hi: 0xc058, Stride: 0x1},
+		unicode.Range16{Lo: 0xc074, Hi: 0xc074, Stride: 0x1},
+		unicode.Range16{Lo: 0xc090, Hi: 0xc090, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0ac, Hi: 0xc0ac, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0c8, Hi: 0xc0c8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0e4, Hi: 0xc0e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc100, Hi: 0xc100, Stride: 0x1},
+		unicode.Range16{Lo: 0xc11c, Hi: 0xc11c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc138, Hi: 0xc138, Stride: 0x1},
+		unicode.Range16{Lo: 0xc154, Hi: 0xc154, Stride: 0x1},
+		unicode.Range16{Lo: 0xc170, Hi: 0xc170, Stride: 0x1},
+		unicode.Range16{Lo: 0xc18c, Hi: 0xc18c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1a8, Hi: 0xc1a8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1c4, Hi: 0xc1c4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1e0, Hi: 0xc1e0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1fc, Hi: 0xc1fc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc218, Hi: 0xc218, Stride: 0x1},
+		unicode.Range16{Lo: 0xc234, Hi: 0xc234, Stride: 0x1},
+		unicode.Range16{Lo: 0xc250, Hi: 0xc250, Stride: 0x1},
+		unicode.Range16{Lo: 0xc26c, Hi: 0xc26c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc288, Hi: 0xc288, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2a4, Hi: 0xc2a4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2c0, Hi: 0xc2c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2dc, Hi: 0xc2dc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2f8, Hi: 0xc2f8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc314, Hi: 0xc314, Stride: 0x1},
+		unicode.Range16{Lo: 0xc330, Hi: 0xc330, Stride: 0x1},
+		unicode.Range16{Lo: 0xc34c, Hi: 0xc34c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc368, Hi: 0xc368, Stride: 0x1},
+		unicode.Range16{Lo: 0xc384, Hi: 0xc384, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3a0, Hi: 0xc3a0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3bc, Hi: 0xc3bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3d8, Hi: 0xc3d8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3f4, Hi: 0xc3f4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc410, Hi: 0xc410, Stride: 0x1},
+		unicode.Range16{Lo: 0xc42c, Hi: 0xc42c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc448, Hi: 0xc448, Stride: 0x1},
+		unicode.Range16{Lo: 0xc464, Hi: 0xc464, Stride: 0x1},
+		unicode.Range16{Lo: 0xc480, Hi: 0xc480, Stride: 0x1},
+		unicode.Range16{Lo: 0xc49c, Hi: 0xc49c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4b8, Hi: 0xc4b8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4d4, Hi: 0xc4d4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4f0, Hi: 0xc4f0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc50c, Hi: 0xc50c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc528, Hi: 0xc528, Stride: 0x1},
+		unicode.Range16{Lo: 0xc544, Hi: 0xc544, Stride: 0x1},
+		unicode.Range16{Lo: 0xc560, Hi: 0xc560, Stride: 0x1},
+		unicode.Range16{Lo: 0xc57c, Hi: 0xc57c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc598, Hi: 0xc598, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5b4, Hi: 0xc5b4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5d0, Hi: 0xc5d0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5ec, Hi: 0xc5ec, Stride: 0x1},
+		unicode.Range16{Lo: 0xc608, Hi: 0xc608, Stride: 0x1},
+		unicode.Range16{Lo: 0xc624, Hi: 0xc624, Stride: 0x1},
+		unicode.Range16{Lo: 0xc640, Hi: 0xc640, Stride: 0x1},
+		unicode.Range16{Lo: 0xc65c, Hi: 0xc65c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc678, Hi: 0xc678, Stride: 0x1},
+		unicode.Range16{Lo: 0xc694, Hi: 0xc694, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6b0, Hi: 0xc6b0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6cc, Hi: 0xc6cc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6e8, Hi: 0xc6e8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc704, Hi: 0xc704, Stride: 0x1},
+		unicode.Range16{Lo: 0xc720, Hi: 0xc720, Stride: 0x1},
+		unicode.Range16{Lo: 0xc73c, Hi: 0xc73c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc758, Hi: 0xc758, Stride: 0x1},
+		unicode.Range16{Lo: 0xc774, Hi: 0xc774, Stride: 0x1},
+		unicode.Range16{Lo: 0xc790, Hi: 0xc790, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7ac, Hi: 0xc7ac, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7c8, Hi: 0xc7c8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7e4, Hi: 0xc7e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc800, Hi: 0xc800, Stride: 0x1},
+		unicode.Range16{Lo: 0xc81c, Hi: 0xc81c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc838, Hi: 0xc838, Stride: 0x1},
+		unicode.Range16{Lo: 0xc854, Hi: 0xc854, Stride: 0x1},
+		unicode.Range16{Lo: 0xc870, Hi: 0xc870, Stride: 0x1},
+		unicode.Range16{Lo: 0xc88c, Hi: 0xc88c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8a8, Hi: 0xc8a8, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8c4, Hi: 0xc8c4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8e0, Hi: 0xc8e0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8fc, Hi: 0xc8fc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc918, Hi: 0xc918, Stride: 0x1},
+		unicode.Range16{Lo: 0xc934, Hi: 0xc934, Stride: 0x1},
+		unicode.Range16{Lo: 0xc950, Hi: 0xc950, Stride: 0x1},
+		unicode.Range16{Lo: 0xc96c, Hi: 0xc96c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc988, Hi: 0xc988, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9a4, Hi: 0xc9a4, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9c0, Hi: 0xc9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9dc, Hi: 0xc9dc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9f8, Hi: 0xc9f8, Stride: 0x1},
+		unicode.Range16{Lo: 0xca14, Hi: 0xca14, Stride: 0x1},
+		unicode.Range16{Lo: 0xca30, Hi: 0xca30, Stride: 0x1},
+		unicode.Range16{Lo: 0xca4c, Hi: 0xca4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xca68, Hi: 0xca68, Stride: 0x1},
+		unicode.Range16{Lo: 0xca84, Hi: 0xca84, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaa0, Hi: 0xcaa0, Stride: 0x1},
+		unicode.Range16{Lo: 0xcabc, Hi: 0xcabc, Stride: 0x1},
+		unicode.Range16{Lo: 0xcad8, Hi: 0xcad8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaf4, Hi: 0xcaf4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb10, Hi: 0xcb10, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb2c, Hi: 0xcb2c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb48, Hi: 0xcb48, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb64, Hi: 0xcb64, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb80, Hi: 0xcb80, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb9c, Hi: 0xcb9c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbb8, Hi: 0xcbb8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbd4, Hi: 0xcbd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbf0, Hi: 0xcbf0, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc0c, Hi: 0xcc0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc28, Hi: 0xcc28, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc44, Hi: 0xcc44, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc60, Hi: 0xcc60, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc7c, Hi: 0xcc7c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc98, Hi: 0xcc98, Stride: 0x1},
+		unicode.Range16{Lo: 0xccb4, Hi: 0xccb4, Stride: 0x1},
+		unicode.Range16{Lo: 0xccd0, Hi: 0xccd0, Stride: 0x1},
+		unicode.Range16{Lo: 0xccec, Hi: 0xccec, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd08, Hi: 0xcd08, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd24, Hi: 0xcd24, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd40, Hi: 0xcd40, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd5c, Hi: 0xcd5c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd78, Hi: 0xcd78, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd94, Hi: 0xcd94, Stride: 0x1},
+		unicode.Range16{Lo: 0xcdb0, Hi: 0xcdb0, Stride: 0x1},
+		unicode.Range16{Lo: 0xcdcc, Hi: 0xcdcc, Stride: 0x1},
+		unicode.Range16{Lo: 0xcde8, Hi: 0xcde8, Stride: 0x1},
+		unicode.Range16{Lo: 0xce04, Hi: 0xce04, Stride: 0x1},
+		unicode.Range16{Lo: 0xce20, Hi: 0xce20, Stride: 0x1},
+		unicode.Range16{Lo: 0xce3c, Hi: 0xce3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xce58, Hi: 0xce58, Stride: 0x1},
+		unicode.Range16{Lo: 0xce74, Hi: 0xce74, Stride: 0x1},
+		unicode.Range16{Lo: 0xce90, Hi: 0xce90, Stride: 0x1},
+		unicode.Range16{Lo: 0xceac, Hi: 0xceac, Stride: 0x1},
+		unicode.Range16{Lo: 0xcec8, Hi: 0xcec8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcee4, Hi: 0xcee4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf00, Hi: 0xcf00, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf1c, Hi: 0xcf1c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf38, Hi: 0xcf38, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf54, Hi: 0xcf54, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf70, Hi: 0xcf70, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf8c, Hi: 0xcf8c, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfa8, Hi: 0xcfa8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfc4, Hi: 0xcfc4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfe0, Hi: 0xcfe0, Stride: 0x1},
+		unicode.Range16{Lo: 0xcffc, Hi: 0xcffc, Stride: 0x1},
+		unicode.Range16{Lo: 0xd018, Hi: 0xd018, Stride: 0x1},
+		unicode.Range16{Lo: 0xd034, Hi: 0xd034, Stride: 0x1},
+		unicode.Range16{Lo: 0xd050, Hi: 0xd050, Stride: 0x1},
+		unicode.Range16{Lo: 0xd06c, Hi: 0xd06c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd088, Hi: 0xd088, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0a4, Hi: 0xd0a4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0c0, Hi: 0xd0c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0dc, Hi: 0xd0dc, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0f8, Hi: 0xd0f8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd114, Hi: 0xd114, Stride: 0x1},
+		unicode.Range16{Lo: 0xd130, Hi: 0xd130, Stride: 0x1},
+		unicode.Range16{Lo: 0xd14c, Hi: 0xd14c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd168, Hi: 0xd168, Stride: 0x1},
+		unicode.Range16{Lo: 0xd184, Hi: 0xd184, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1a0, Hi: 0xd1a0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1bc, Hi: 0xd1bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1d8, Hi: 0xd1d8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1f4, Hi: 0xd1f4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd210, Hi: 0xd210, Stride: 0x1},
+		unicode.Range16{Lo: 0xd22c, Hi: 0xd22c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd248, Hi: 0xd248, Stride: 0x1},
+		unicode.Range16{Lo: 0xd264, Hi: 0xd264, Stride: 0x1},
+		unicode.Range16{Lo: 0xd280, Hi: 0xd280, Stride: 0x1},
+		unicode.Range16{Lo: 0xd29c, Hi: 0xd29c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2b8, Hi: 0xd2b8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2d4, Hi: 0xd2d4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2f0, Hi: 0xd2f0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd30c, Hi: 0xd30c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd328, Hi: 0xd328, Stride: 0x1},
+		unicode.Range16{Lo: 0xd344, Hi: 0xd344, Stride: 0x1},
+		unicode.Range16{Lo: 0xd360, Hi: 0xd360, Stride: 0x1},
+		unicode.Range16{Lo: 0xd37c, Hi: 0xd37c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd398, Hi: 0xd398, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3b4, Hi: 0xd3b4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3d0, Hi: 0xd3d0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3ec, Hi: 0xd3ec, Stride: 0x1},
+		unicode.Range16{Lo: 0xd408, Hi: 0xd408, Stride: 0x1},
+		unicode.Range16{Lo: 0xd424, Hi: 0xd424, Stride: 0x1},
+		unicode.Range16{Lo: 0xd440, Hi: 0xd440, Stride: 0x1},
+		unicode.Range16{Lo: 0xd45c, Hi: 0xd45c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd478, Hi: 0xd478, Stride: 0x1},
+		unicode.Range16{Lo: 0xd494, Hi: 0xd494, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4b0, Hi: 0xd4b0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4cc, Hi: 0xd4cc, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4e8, Hi: 0xd4e8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd504, Hi: 0xd504, Stride: 0x1},
+		unicode.Range16{Lo: 0xd520, Hi: 0xd520, Stride: 0x1},
+		unicode.Range16{Lo: 0xd53c, Hi: 0xd53c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd558, Hi: 0xd558, Stride: 0x1},
+		unicode.Range16{Lo: 0xd574, Hi: 0xd574, Stride: 0x1},
+		unicode.Range16{Lo: 0xd590, Hi: 0xd590, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5ac, Hi: 0xd5ac, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5c8, Hi: 0xd5c8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5e4, Hi: 0xd5e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd600, Hi: 0xd600, Stride: 0x1},
+		unicode.Range16{Lo: 0xd61c, Hi: 0xd61c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd638, Hi: 0xd638, Stride: 0x1},
+		unicode.Range16{Lo: 0xd654, Hi: 0xd654, Stride: 0x1},
+		unicode.Range16{Lo: 0xd670, Hi: 0xd670, Stride: 0x1},
+		unicode.Range16{Lo: 0xd68c, Hi: 0xd68c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6a8, Hi: 0xd6a8, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6c4, Hi: 0xd6c4, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6e0, Hi: 0xd6e0, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6fc, Hi: 0xd6fc, Stride: 0x1},
+		unicode.Range16{Lo: 0xd718, Hi: 0xd718, Stride: 0x1},
+		unicode.Range16{Lo: 0xd734, Hi: 0xd734, Stride: 0x1},
+		unicode.Range16{Lo: 0xd750, Hi: 0xd750, Stride: 0x1},
+		unicode.Range16{Lo: 0xd76c, Hi: 0xd76c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd788, Hi: 0xd788, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeLVT = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xac01, Hi: 0xac1b, Stride: 0x1},
+		unicode.Range16{Lo: 0xac1d, Hi: 0xac37, Stride: 0x1},
+		unicode.Range16{Lo: 0xac39, Hi: 0xac53, Stride: 0x1},
+		unicode.Range16{Lo: 0xac55, Hi: 0xac6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xac71, Hi: 0xac8b, Stride: 0x1},
+		unicode.Range16{Lo: 0xac8d, Hi: 0xaca7, Stride: 0x1},
+		unicode.Range16{Lo: 0xaca9, Hi: 0xacc3, Stride: 0x1},
+		unicode.Range16{Lo: 0xacc5, Hi: 0xacdf, Stride: 0x1},
+		unicode.Range16{Lo: 0xace1, Hi: 0xacfb, Stride: 0x1},
+		unicode.Range16{Lo: 0xacfd, Hi: 0xad17, Stride: 0x1},
+		unicode.Range16{Lo: 0xad19, Hi: 0xad33, Stride: 0x1},
+		unicode.Range16{Lo: 0xad35, Hi: 0xad4f, Stride: 0x1},
+		unicode.Range16{Lo: 0xad51, Hi: 0xad6b, Stride: 0x1},
+		unicode.Range16{Lo: 0xad6d, Hi: 0xad87, Stride: 0x1},
+		unicode.Range16{Lo: 0xad89, Hi: 0xada3, Stride: 0x1},
+		unicode.Range16{Lo: 0xada5, Hi: 0xadbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xadc1, Hi: 0xaddb, Stride: 0x1},
+		unicode.Range16{Lo: 0xaddd, Hi: 0xadf7, Stride: 0x1},
+		unicode.Range16{Lo: 0xadf9, Hi: 0xae13, Stride: 0x1},
+		unicode.Range16{Lo: 0xae15, Hi: 0xae2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xae31, Hi: 0xae4b, Stride: 0x1},
+		unicode.Range16{Lo: 0xae4d, Hi: 0xae67, Stride: 0x1},
+		unicode.Range16{Lo: 0xae69, Hi: 0xae83, Stride: 0x1},
+		unicode.Range16{Lo: 0xae85, Hi: 0xae9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xaea1, Hi: 0xaebb, Stride: 0x1},
+		unicode.Range16{Lo: 0xaebd, Hi: 0xaed7, Stride: 0x1},
+		unicode.Range16{Lo: 0xaed9, Hi: 0xaef3, Stride: 0x1},
+		unicode.Range16{Lo: 0xaef5, Hi: 0xaf0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf11, Hi: 0xaf2b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf2d, Hi: 0xaf47, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf49, Hi: 0xaf63, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf65, Hi: 0xaf7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf81, Hi: 0xaf9b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf9d, Hi: 0xafb7, Stride: 0x1},
+		unicode.Range16{Lo: 0xafb9, Hi: 0xafd3, Stride: 0x1},
+		unicode.Range16{Lo: 0xafd5, Hi: 0xafef, Stride: 0x1},
+		unicode.Range16{Lo: 0xaff1, Hi: 0xb00b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb00d, Hi: 0xb027, Stride: 0x1},
+		unicode.Range16{Lo: 0xb029, Hi: 0xb043, Stride: 0x1},
+		unicode.Range16{Lo: 0xb045, Hi: 0xb05f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb061, Hi: 0xb07b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb07d, Hi: 0xb097, Stride: 0x1},
+		unicode.Range16{Lo: 0xb099, Hi: 0xb0b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0b5, Hi: 0xb0cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0d1, Hi: 0xb0eb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0ed, Hi: 0xb107, Stride: 0x1},
+		unicode.Range16{Lo: 0xb109, Hi: 0xb123, Stride: 0x1},
+		unicode.Range16{Lo: 0xb125, Hi: 0xb13f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb141, Hi: 0xb15b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb15d, Hi: 0xb177, Stride: 0x1},
+		unicode.Range16{Lo: 0xb179, Hi: 0xb193, Stride: 0x1},
+		unicode.Range16{Lo: 0xb195, Hi: 0xb1af, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1b1, Hi: 0xb1cb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1cd, Hi: 0xb1e7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb1e9, Hi: 0xb203, Stride: 0x1},
+		unicode.Range16{Lo: 0xb205, Hi: 0xb21f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb221, Hi: 0xb23b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb23d, Hi: 0xb257, Stride: 0x1},
+		unicode.Range16{Lo: 0xb259, Hi: 0xb273, Stride: 0x1},
+		unicode.Range16{Lo: 0xb275, Hi: 0xb28f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb291, Hi: 0xb2ab, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2ad, Hi: 0xb2c7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2c9, Hi: 0xb2e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2e5, Hi: 0xb2ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xb301, Hi: 0xb31b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb31d, Hi: 0xb337, Stride: 0x1},
+		unicode.Range16{Lo: 0xb339, Hi: 0xb353, Stride: 0x1},
+		unicode.Range16{Lo: 0xb355, Hi: 0xb36f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb371, Hi: 0xb38b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb38d, Hi: 0xb3a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3a9, Hi: 0xb3c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3c5, Hi: 0xb3df, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3e1, Hi: 0xb3fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3fd, Hi: 0xb417, Stride: 0x1},
+		unicode.Range16{Lo: 0xb419, Hi: 0xb433, Stride: 0x1},
+		unicode.Range16{Lo: 0xb435, Hi: 0xb44f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb451, Hi: 0xb46b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb46d, Hi: 0xb487, Stride: 0x1},
+		unicode.Range16{Lo: 0xb489, Hi: 0xb4a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4a5, Hi: 0xb4bf, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4c1, Hi: 0xb4db, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4dd, Hi: 0xb4f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4f9, Hi: 0xb513, Stride: 0x1},
+		unicode.Range16{Lo: 0xb515, Hi: 0xb52f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb531, Hi: 0xb54b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb54d, Hi: 0xb567, Stride: 0x1},
+		unicode.Range16{Lo: 0xb569, Hi: 0xb583, Stride: 0x1},
+		unicode.Range16{Lo: 0xb585, Hi: 0xb59f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5a1, Hi: 0xb5bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5bd, Hi: 0xb5d7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5d9, Hi: 0xb5f3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5f5, Hi: 0xb60f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb611, Hi: 0xb62b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb62d, Hi: 0xb647, Stride: 0x1},
+		unicode.Range16{Lo: 0xb649, Hi: 0xb663, Stride: 0x1},
+		unicode.Range16{Lo: 0xb665, Hi: 0xb67f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb681, Hi: 0xb69b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb69d, Hi: 0xb6b7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6b9, Hi: 0xb6d3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6d5, Hi: 0xb6ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xb6f1, Hi: 0xb70b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb70d, Hi: 0xb727, Stride: 0x1},
+		unicode.Range16{Lo: 0xb729, Hi: 0xb743, Stride: 0x1},
+		unicode.Range16{Lo: 0xb745, Hi: 0xb75f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb761, Hi: 0xb77b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb77d, Hi: 0xb797, Stride: 0x1},
+		unicode.Range16{Lo: 0xb799, Hi: 0xb7b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7b5, Hi: 0xb7cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7d1, Hi: 0xb7eb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7ed, Hi: 0xb807, Stride: 0x1},
+		unicode.Range16{Lo: 0xb809, Hi: 0xb823, Stride: 0x1},
+		unicode.Range16{Lo: 0xb825, Hi: 0xb83f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb841, Hi: 0xb85b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb85d, Hi: 0xb877, Stride: 0x1},
+		unicode.Range16{Lo: 0xb879, Hi: 0xb893, Stride: 0x1},
+		unicode.Range16{Lo: 0xb895, Hi: 0xb8af, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8b1, Hi: 0xb8cb, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8cd, Hi: 0xb8e7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8e9, Hi: 0xb903, Stride: 0x1},
+		unicode.Range16{Lo: 0xb905, Hi: 0xb91f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb921, Hi: 0xb93b, Stride: 0x1},
+		unicode.Range16{Lo: 0xb93d, Hi: 0xb957, Stride: 0x1},
+		unicode.Range16{Lo: 0xb959, Hi: 0xb973, Stride: 0x1},
+		unicode.Range16{Lo: 0xb975, Hi: 0xb98f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb991, Hi: 0xb9ab, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9ad, Hi: 0xb9c7, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9c9, Hi: 0xb9e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9e5, Hi: 0xb9ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xba01, Hi: 0xba1b, Stride: 0x1},
+		unicode.Range16{Lo: 0xba1d, Hi: 0xba37, Stride: 0x1},
+		unicode.Range16{Lo: 0xba39, Hi: 0xba53, Stride: 0x1},
+		unicode.Range16{Lo: 0xba55, Hi: 0xba6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xba71, Hi: 0xba8b, Stride: 0x1},
+		unicode.Range16{Lo: 0xba8d, Hi: 0xbaa7, Stride: 0x1},
+		unicode.Range16{Lo: 0xbaa9, Hi: 0xbac3, Stride: 0x1},
+		unicode.Range16{Lo: 0xbac5, Hi: 0xbadf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbae1, Hi: 0xbafb, Stride: 0x1},
+		unicode.Range16{Lo: 0xbafd, Hi: 0xbb17, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb19, Hi: 0xbb33, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb35, Hi: 0xbb4f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb51, Hi: 0xbb6b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb6d, Hi: 0xbb87, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb89, Hi: 0xbba3, Stride: 0x1},
+		unicode.Range16{Lo: 0xbba5, Hi: 0xbbbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbc1, Hi: 0xbbdb, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbdd, Hi: 0xbbf7, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbf9, Hi: 0xbc13, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc15, Hi: 0xbc2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc31, Hi: 0xbc4b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc4d, Hi: 0xbc67, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc69, Hi: 0xbc83, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc85, Hi: 0xbc9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbca1, Hi: 0xbcbb, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcbd, Hi: 0xbcd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcd9, Hi: 0xbcf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcf5, Hi: 0xbd0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd11, Hi: 0xbd2b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd2d, Hi: 0xbd47, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd49, Hi: 0xbd63, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd65, Hi: 0xbd7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd81, Hi: 0xbd9b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd9d, Hi: 0xbdb7, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdb9, Hi: 0xbdd3, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdd5, Hi: 0xbdef, Stride: 0x1},
+		unicode.Range16{Lo: 0xbdf1, Hi: 0xbe0b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe0d, Hi: 0xbe27, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe29, Hi: 0xbe43, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe45, Hi: 0xbe5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe61, Hi: 0xbe7b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe7d, Hi: 0xbe97, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe99, Hi: 0xbeb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xbeb5, Hi: 0xbecf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbed1, Hi: 0xbeeb, Stride: 0x1},
+		unicode.Range16{Lo: 0xbeed, Hi: 0xbf07, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf09, Hi: 0xbf23, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf25, Hi: 0xbf3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf41, Hi: 0xbf5b, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf5d, Hi: 0xbf77, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf79, Hi: 0xbf93, Stride: 0x1},
+		unicode.Range16{Lo: 0xbf95, Hi: 0xbfaf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfb1, Hi: 0xbfcb, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfcd, Hi: 0xbfe7, Stride: 0x1},
+		unicode.Range16{Lo: 0xbfe9, Hi: 0xc003, Stride: 0x1},
+		unicode.Range16{Lo: 0xc005, Hi: 0xc01f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc021, Hi: 0xc03b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc03d, Hi: 0xc057, Stride: 0x1},
+		unicode.Range16{Lo: 0xc059, Hi: 0xc073, Stride: 0x1},
+		unicode.Range16{Lo: 0xc075, Hi: 0xc08f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc091, Hi: 0xc0ab, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0ad, Hi: 0xc0c7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0c9, Hi: 0xc0e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0e5, Hi: 0xc0ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xc101, Hi: 0xc11b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc11d, Hi: 0xc137, Stride: 0x1},
+		unicode.Range16{Lo: 0xc139, Hi: 0xc153, Stride: 0x1},
+		unicode.Range16{Lo: 0xc155, Hi: 0xc16f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc171, Hi: 0xc18b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc18d, Hi: 0xc1a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1a9, Hi: 0xc1c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1c5, Hi: 0xc1df, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1e1, Hi: 0xc1fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xc1fd, Hi: 0xc217, Stride: 0x1},
+		unicode.Range16{Lo: 0xc219, Hi: 0xc233, Stride: 0x1},
+		unicode.Range16{Lo: 0xc235, Hi: 0xc24f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc251, Hi: 0xc26b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc26d, Hi: 0xc287, Stride: 0x1},
+		unicode.Range16{Lo: 0xc289, Hi: 0xc2a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2a5, Hi: 0xc2bf, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2c1, Hi: 0xc2db, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2dd, Hi: 0xc2f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2f9, Hi: 0xc313, Stride: 0x1},
+		unicode.Range16{Lo: 0xc315, Hi: 0xc32f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc331, Hi: 0xc34b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc34d, Hi: 0xc367, Stride: 0x1},
+		unicode.Range16{Lo: 0xc369, Hi: 0xc383, Stride: 0x1},
+		unicode.Range16{Lo: 0xc385, Hi: 0xc39f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3a1, Hi: 0xc3bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3bd, Hi: 0xc3d7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3d9, Hi: 0xc3f3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3f5, Hi: 0xc40f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc411, Hi: 0xc42b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc42d, Hi: 0xc447, Stride: 0x1},
+		unicode.Range16{Lo: 0xc449, Hi: 0xc463, Stride: 0x1},
+		unicode.Range16{Lo: 0xc465, Hi: 0xc47f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc481, Hi: 0xc49b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc49d, Hi: 0xc4b7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4b9, Hi: 0xc4d3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4d5, Hi: 0xc4ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4f1, Hi: 0xc50b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc50d, Hi: 0xc527, Stride: 0x1},
+		unicode.Range16{Lo: 0xc529, Hi: 0xc543, Stride: 0x1},
+		unicode.Range16{Lo: 0xc545, Hi: 0xc55f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc561, Hi: 0xc57b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc57d, Hi: 0xc597, Stride: 0x1},
+		unicode.Range16{Lo: 0xc599, Hi: 0xc5b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5b5, Hi: 0xc5cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5d1, Hi: 0xc5eb, Stride: 0x1},
+		unicode.Range16{Lo: 0xc5ed, Hi: 0xc607, Stride: 0x1},
+		unicode.Range16{Lo: 0xc609, Hi: 0xc623, Stride: 0x1},
+		unicode.Range16{Lo: 0xc625, Hi: 0xc63f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc641, Hi: 0xc65b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc65d, Hi: 0xc677, Stride: 0x1},
+		unicode.Range16{Lo: 0xc679, Hi: 0xc693, Stride: 0x1},
+		unicode.Range16{Lo: 0xc695, Hi: 0xc6af, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6b1, Hi: 0xc6cb, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6cd, Hi: 0xc6e7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc6e9, Hi: 0xc703, Stride: 0x1},
+		unicode.Range16{Lo: 0xc705, Hi: 0xc71f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc721, Hi: 0xc73b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc73d, Hi: 0xc757, Stride: 0x1},
+		unicode.Range16{Lo: 0xc759, Hi: 0xc773, Stride: 0x1},
+		unicode.Range16{Lo: 0xc775, Hi: 0xc78f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc791, Hi: 0xc7ab, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7ad, Hi: 0xc7c7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7c9, Hi: 0xc7e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc7e5, Hi: 0xc7ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xc801, Hi: 0xc81b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc81d, Hi: 0xc837, Stride: 0x1},
+		unicode.Range16{Lo: 0xc839, Hi: 0xc853, Stride: 0x1},
+		unicode.Range16{Lo: 0xc855, Hi: 0xc86f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc871, Hi: 0xc88b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc88d, Hi: 0xc8a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8a9, Hi: 0xc8c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8c5, Hi: 0xc8df, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8e1, Hi: 0xc8fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8fd, Hi: 0xc917, Stride: 0x1},
+		unicode.Range16{Lo: 0xc919, Hi: 0xc933, Stride: 0x1},
+		unicode.Range16{Lo: 0xc935, Hi: 0xc94f, Stride: 0x1},
+		unicode.Range16{Lo: 0xc951, Hi: 0xc96b, Stride: 0x1},
+		unicode.Range16{Lo: 0xc96d, Hi: 0xc987, Stride: 0x1},
+		unicode.Range16{Lo: 0xc989, Hi: 0xc9a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9a5, Hi: 0xc9bf, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9c1, Hi: 0xc9db, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9dd, Hi: 0xc9f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc9f9, Hi: 0xca13, Stride: 0x1},
+		unicode.Range16{Lo: 0xca15, Hi: 0xca2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xca31, Hi: 0xca4b, Stride: 0x1},
+		unicode.Range16{Lo: 0xca4d, Hi: 0xca67, Stride: 0x1},
+		unicode.Range16{Lo: 0xca69, Hi: 0xca83, Stride: 0x1},
+		unicode.Range16{Lo: 0xca85, Hi: 0xca9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaa1, Hi: 0xcabb, Stride: 0x1},
+		unicode.Range16{Lo: 0xcabd, Hi: 0xcad7, Stride: 0x1},
+		unicode.Range16{Lo: 0xcad9, Hi: 0xcaf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaf5, Hi: 0xcb0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb11, Hi: 0xcb2b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb2d, Hi: 0xcb47, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb49, Hi: 0xcb63, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb65, Hi: 0xcb7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb81, Hi: 0xcb9b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb9d, Hi: 0xcbb7, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbb9, Hi: 0xcbd3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbd5, Hi: 0xcbef, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbf1, Hi: 0xcc0b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc0d, Hi: 0xcc27, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc29, Hi: 0xcc43, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc45, Hi: 0xcc5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc61, Hi: 0xcc7b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc7d, Hi: 0xcc97, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc99, Hi: 0xccb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xccb5, Hi: 0xcccf, Stride: 0x1},
+		unicode.Range16{Lo: 0xccd1, Hi: 0xcceb, Stride: 0x1},
+		unicode.Range16{Lo: 0xcced, Hi: 0xcd07, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd09, Hi: 0xcd23, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd25, Hi: 0xcd3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd41, Hi: 0xcd5b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd5d, Hi: 0xcd77, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd79, Hi: 0xcd93, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd95, Hi: 0xcdaf, Stride: 0x1},
+		unicode.Range16{Lo: 0xcdb1, Hi: 0xcdcb, Stride: 0x1},
+		unicode.Range16{Lo: 0xcdcd, Hi: 0xcde7, Stride: 0x1},
+		unicode.Range16{Lo: 0xcde9, Hi: 0xce03, Stride: 0x1},
+		unicode.Range16{Lo: 0xce05, Hi: 0xce1f, Stride: 0x1},
+		unicode.Range16{Lo: 0xce21, Hi: 0xce3b, Stride: 0x1},
+		unicode.Range16{Lo: 0xce3d, Hi: 0xce57, Stride: 0x1},
+		unicode.Range16{Lo: 0xce59, Hi: 0xce73, Stride: 0x1},
+		unicode.Range16{Lo: 0xce75, Hi: 0xce8f, Stride: 0x1},
+		unicode.Range16{Lo: 0xce91, Hi: 0xceab, Stride: 0x1},
+		unicode.Range16{Lo: 0xcead, Hi: 0xcec7, Stride: 0x1},
+		unicode.Range16{Lo: 0xcec9, Hi: 0xcee3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcee5, Hi: 0xceff, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf01, Hi: 0xcf1b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf1d, Hi: 0xcf37, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf39, Hi: 0xcf53, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf55, Hi: 0xcf6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf71, Hi: 0xcf8b, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf8d, Hi: 0xcfa7, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfa9, Hi: 0xcfc3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfc5, Hi: 0xcfdf, Stride: 0x1},
+		unicode.Range16{Lo: 0xcfe1, Hi: 0xcffb, Stride: 0x1},
+		unicode.Range16{Lo: 0xcffd, Hi: 0xd017, Stride: 0x1},
+		unicode.Range16{Lo: 0xd019, Hi: 0xd033, Stride: 0x1},
+		unicode.Range16{Lo: 0xd035, Hi: 0xd04f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd051, Hi: 0xd06b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd06d, Hi: 0xd087, Stride: 0x1},
+		unicode.Range16{Lo: 0xd089, Hi: 0xd0a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0a5, Hi: 0xd0bf, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0c1, Hi: 0xd0db, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0dd, Hi: 0xd0f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0f9, Hi: 0xd113, Stride: 0x1},
+		unicode.Range16{Lo: 0xd115, Hi: 0xd12f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd131, Hi: 0xd14b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd14d, Hi: 0xd167, Stride: 0x1},
+		unicode.Range16{Lo: 0xd169, Hi: 0xd183, Stride: 0x1},
+		unicode.Range16{Lo: 0xd185, Hi: 0xd19f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1a1, Hi: 0xd1bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1bd, Hi: 0xd1d7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1d9, Hi: 0xd1f3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd1f5, Hi: 0xd20f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd211, Hi: 0xd22b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd22d, Hi: 0xd247, Stride: 0x1},
+		unicode.Range16{Lo: 0xd249, Hi: 0xd263, Stride: 0x1},
+		unicode.Range16{Lo: 0xd265, Hi: 0xd27f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd281, Hi: 0xd29b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd29d, Hi: 0xd2b7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2b9, Hi: 0xd2d3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2d5, Hi: 0xd2ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xd2f1, Hi: 0xd30b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd30d, Hi: 0xd327, Stride: 0x1},
+		unicode.Range16{Lo: 0xd329, Hi: 0xd343, Stride: 0x1},
+		unicode.Range16{Lo: 0xd345, Hi: 0xd35f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd361, Hi: 0xd37b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd37d, Hi: 0xd397, Stride: 0x1},
+		unicode.Range16{Lo: 0xd399, Hi: 0xd3b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3b5, Hi: 0xd3cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3d1, Hi: 0xd3eb, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3ed, Hi: 0xd407, Stride: 0x1},
+		unicode.Range16{Lo: 0xd409, Hi: 0xd423, Stride: 0x1},
+		unicode.Range16{Lo: 0xd425, Hi: 0xd43f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd441, Hi: 0xd45b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd45d, Hi: 0xd477, Stride: 0x1},
+		unicode.Range16{Lo: 0xd479, Hi: 0xd493, Stride: 0x1},
+		unicode.Range16{Lo: 0xd495, Hi: 0xd4af, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4b1, Hi: 0xd4cb, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4cd, Hi: 0xd4e7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4e9, Hi: 0xd503, Stride: 0x1},
+		unicode.Range16{Lo: 0xd505, Hi: 0xd51f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd521, Hi: 0xd53b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd53d, Hi: 0xd557, Stride: 0x1},
+		unicode.Range16{Lo: 0xd559, Hi: 0xd573, Stride: 0x1},
+		unicode.Range16{Lo: 0xd575, Hi: 0xd58f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd591, Hi: 0xd5ab, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5ad, Hi: 0xd5c7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5c9, Hi: 0xd5e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5e5, Hi: 0xd5ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xd601, Hi: 0xd61b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd61d, Hi: 0xd637, Stride: 0x1},
+		unicode.Range16{Lo: 0xd639, Hi: 0xd653, Stride: 0x1},
+		unicode.Range16{Lo: 0xd655, Hi: 0xd66f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd671, Hi: 0xd68b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd68d, Hi: 0xd6a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6a9, Hi: 0xd6c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6c5, Hi: 0xd6df, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6e1, Hi: 0xd6fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xd6fd, Hi: 0xd717, Stride: 0x1},
+		unicode.Range16{Lo: 0xd719, Hi: 0xd733, Stride: 0x1},
+		unicode.Range16{Lo: 0xd735, Hi: 0xd74f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd751, Hi: 0xd76b, Stride: 0x1},
+		unicode.Range16{Lo: 0xd76d, Hi: 0xd787, Stride: 0x1},
+		unicode.Range16{Lo: 0xd789, Hi: 0xd7a3, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemePrepend = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x600, Hi: 0x605, Stride: 0x1},
+		unicode.Range16{Lo: 0x6dd, Hi: 0x6dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x70f, Hi: 0x70f, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e2, Hi: 0x8e2, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4e, Hi: 0xd4e, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x110bd, Hi: 0x110bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x111c2, Hi: 0x111c3, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeRegional_Indicator = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f1e6, Hi: 0x1f1ff, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeSpacingMark = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x903, Hi: 0x903, Stride: 0x1},
+		unicode.Range16{Lo: 0x93b, Hi: 0x93b, Stride: 0x1},
+		unicode.Range16{Lo: 0x93e, Hi: 0x940, Stride: 0x1},
+		unicode.Range16{Lo: 0x949, Hi: 0x94c, Stride: 0x1},
+		unicode.Range16{Lo: 0x94e, Hi: 0x94f, Stride: 0x1},
+		unicode.Range16{Lo: 0x982, Hi: 0x983, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bf, Hi: 0x9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c7, Hi: 0x9c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cb, Hi: 0x9cc, Stride: 0x1},
+		unicode.Range16{Lo: 0xa03, Hi: 0xa03, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3e, Hi: 0xa40, Stride: 0x1},
+		unicode.Range16{Lo: 0xa83, Hi: 0xa83, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe, Hi: 0xac0, Stride: 0x1},
+		unicode.Range16{Lo: 0xac9, Hi: 0xac9, Stride: 0x1},
+		unicode.Range16{Lo: 0xacb, Hi: 0xacc, Stride: 0x1},
+		unicode.Range16{Lo: 0xb02, Hi: 0xb03, Stride: 0x1},
+		unicode.Range16{Lo: 0xb40, Hi: 0xb40, Stride: 0x1},
+		unicode.Range16{Lo: 0xb47, Hi: 0xb48, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4b, Hi: 0xb4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbf, Hi: 0xbbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc1, Hi: 0xbc2, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc6, Hi: 0xbc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbca, Hi: 0xbcc, Stride: 0x1},
+		unicode.Range16{Lo: 0xc01, Hi: 0xc03, Stride: 0x1},
+		unicode.Range16{Lo: 0xc41, Hi: 0xc44, Stride: 0x1},
+		unicode.Range16{Lo: 0xc82, Hi: 0xc83, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbe, Hi: 0xcbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc0, Hi: 0xcc1, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc3, Hi: 0xcc4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc7, Hi: 0xcc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcca, Hi: 0xccb, Stride: 0x1},
+		unicode.Range16{Lo: 0xd02, Hi: 0xd03, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3f, Hi: 0xd40, Stride: 0x1},
+		unicode.Range16{Lo: 0xd46, Hi: 0xd48, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4a, Hi: 0xd4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd82, Hi: 0xd83, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd0, Hi: 0xdd1, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd8, Hi: 0xdde, Stride: 0x1},
+		unicode.Range16{Lo: 0xdf2, Hi: 0xdf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xe33, Hi: 0xe33, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb3, Hi: 0xeb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3e, Hi: 0xf3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xf7f, Hi: 0xf7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1031, Hi: 0x1031, Stride: 0x1},
+		unicode.Range16{Lo: 0x103b, Hi: 0x103c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1056, Hi: 0x1057, Stride: 0x1},
+		unicode.Range16{Lo: 0x1084, Hi: 0x1084, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b6, Hi: 0x17b6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17be, Hi: 0x17c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c7, Hi: 0x17c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1923, Hi: 0x1926, Stride: 0x1},
+		unicode.Range16{Lo: 0x1929, Hi: 0x192b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1930, Hi: 0x1931, Stride: 0x1},
+		unicode.Range16{Lo: 0x1933, Hi: 0x1938, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a19, Hi: 0x1a1a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a55, Hi: 0x1a55, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a57, Hi: 0x1a57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a6d, Hi: 0x1a72, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b04, Hi: 0x1b04, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b35, Hi: 0x1b35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3b, Hi: 0x1b3b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3d, Hi: 0x1b41, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b43, Hi: 0x1b44, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b82, Hi: 0x1b82, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba1, Hi: 0x1ba1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba6, Hi: 0x1ba7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1baa, Hi: 0x1baa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be7, Hi: 0x1be7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bea, Hi: 0x1bec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bee, Hi: 0x1bee, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bf2, Hi: 0x1bf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c24, Hi: 0x1c2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c34, Hi: 0x1c35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce1, Hi: 0x1ce1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf2, Hi: 0x1cf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa823, Hi: 0xa824, Stride: 0x1},
+		unicode.Range16{Lo: 0xa827, Hi: 0xa827, Stride: 0x1},
+		unicode.Range16{Lo: 0xa880, Hi: 0xa881, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8b4, Hi: 0xa8c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa952, Hi: 0xa953, Stride: 0x1},
+		unicode.Range16{Lo: 0xa983, Hi: 0xa983, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b4, Hi: 0xa9b5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9ba, Hi: 0xa9bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bd, Hi: 0xa9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa2f, Hi: 0xaa30, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa33, Hi: 0xaa34, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4d, Hi: 0xaa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaeb, Hi: 0xaaeb, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaee, Hi: 0xaaef, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf5, Hi: 0xaaf5, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe3, Hi: 0xabe4, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe6, Hi: 0xabe7, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe9, Hi: 0xabea, Stride: 0x1},
+		unicode.Range16{Lo: 0xabec, Hi: 0xabec, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x11000, Hi: 0x11000, Stride: 0x1},
+		unicode.Range32{Lo: 0x11002, Hi: 0x11002, Stride: 0x1},
+		unicode.Range32{Lo: 0x11082, Hi: 0x11082, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b0, Hi: 0x110b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b7, Hi: 0x110b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112c, Hi: 0x1112c, Stride: 0x1},
+		unicode.Range32{Lo: 0x11182, Hi: 0x11182, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b3, Hi: 0x111b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x111bf, Hi: 0x111c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122c, Hi: 0x1122e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11232, Hi: 0x11233, Stride: 0x1},
+		unicode.Range32{Lo: 0x11235, Hi: 0x11235, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e0, Hi: 0x112e2, Stride: 0x1},
+		unicode.Range32{Lo: 0x11302, Hi: 0x11303, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133f, Hi: 0x1133f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11341, Hi: 0x11344, Stride: 0x1},
+		unicode.Range32{Lo: 0x11347, Hi: 0x11348, Stride: 0x1},
+		unicode.Range32{Lo: 0x1134b, Hi: 0x1134d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11362, Hi: 0x11363, Stride: 0x1},
+		unicode.Range32{Lo: 0x11435, Hi: 0x11437, Stride: 0x1},
+		unicode.Range32{Lo: 0x11440, Hi: 0x11441, Stride: 0x1},
+		unicode.Range32{Lo: 0x11445, Hi: 0x11445, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b1, Hi: 0x114b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b9, Hi: 0x114b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bb, Hi: 0x114bc, Stride: 0x1},
+		unicode.Range32{Lo: 0x114be, Hi: 0x114be, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c1, Hi: 0x114c1, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b0, Hi: 0x115b1, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b8, Hi: 0x115bb, Stride: 0x1},
+		unicode.Range32{Lo: 0x115be, Hi: 0x115be, Stride: 0x1},
+		unicode.Range32{Lo: 0x11630, Hi: 0x11632, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163b, Hi: 0x1163c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163e, Hi: 0x1163e, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ac, Hi: 0x116ac, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ae, Hi: 0x116af, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b6, Hi: 0x116b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x11720, Hi: 0x11721, Stride: 0x1},
+		unicode.Range32{Lo: 0x11726, Hi: 0x11726, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c2f, Hi: 0x11c2f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3e, Hi: 0x11c3e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11ca9, Hi: 0x11ca9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb1, Hi: 0x11cb1, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb4, Hi: 0x11cb4, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f51, Hi: 0x16f7e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d166, Hi: 0x1d166, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d16d, Hi: 0x1d16d, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeT = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x11a8, Hi: 0x11ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7cb, Hi: 0xd7fb, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeV = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x1160, Hi: 0x11a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7b0, Hi: 0xd7c6, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _GraphemeZWJ = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x200d, Hi: 0x200d, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+type _GraphemeRuneRange unicode.RangeTable
+
+func _GraphemeRuneType(r rune) *_GraphemeRuneRange {
+	switch {
+	case unicode.Is(_GraphemeCR, r):
+		return (*_GraphemeRuneRange)(_GraphemeCR)
+	case unicode.Is(_GraphemeControl, r):
+		return (*_GraphemeRuneRange)(_GraphemeControl)
+	case unicode.Is(_GraphemeE_Base, r):
+		return (*_GraphemeRuneRange)(_GraphemeE_Base)
+	case unicode.Is(_GraphemeE_Base_GAZ, r):
+		return (*_GraphemeRuneRange)(_GraphemeE_Base_GAZ)
+	case unicode.Is(_GraphemeE_Modifier, r):
+		return (*_GraphemeRuneRange)(_GraphemeE_Modifier)
+	case unicode.Is(_GraphemeExtend, r):
+		return (*_GraphemeRuneRange)(_GraphemeExtend)
+	case unicode.Is(_GraphemeGlue_After_Zwj, r):
+		return (*_GraphemeRuneRange)(_GraphemeGlue_After_Zwj)
+	case unicode.Is(_GraphemeL, r):
+		return (*_GraphemeRuneRange)(_GraphemeL)
+	case unicode.Is(_GraphemeLF, r):
+		return (*_GraphemeRuneRange)(_GraphemeLF)
+	case unicode.Is(_GraphemeLV, r):
+		return (*_GraphemeRuneRange)(_GraphemeLV)
+	case unicode.Is(_GraphemeLVT, r):
+		return (*_GraphemeRuneRange)(_GraphemeLVT)
+	case unicode.Is(_GraphemePrepend, r):
+		return (*_GraphemeRuneRange)(_GraphemePrepend)
+	case unicode.Is(_GraphemeRegional_Indicator, r):
+		return (*_GraphemeRuneRange)(_GraphemeRegional_Indicator)
+	case unicode.Is(_GraphemeSpacingMark, r):
+		return (*_GraphemeRuneRange)(_GraphemeSpacingMark)
+	case unicode.Is(_GraphemeT, r):
+		return (*_GraphemeRuneRange)(_GraphemeT)
+	case unicode.Is(_GraphemeV, r):
+		return (*_GraphemeRuneRange)(_GraphemeV)
+	case unicode.Is(_GraphemeZWJ, r):
+		return (*_GraphemeRuneRange)(_GraphemeZWJ)
+	default:
+		return nil
+	}
+}
+func (rng *_GraphemeRuneRange) String() string {
+	switch (*unicode.RangeTable)(rng) {
+	case _GraphemeCR:
+		return "CR"
+	case _GraphemeControl:
+		return "Control"
+	case _GraphemeE_Base:
+		return "E_Base"
+	case _GraphemeE_Base_GAZ:
+		return "E_Base_GAZ"
+	case _GraphemeE_Modifier:
+		return "E_Modifier"
+	case _GraphemeExtend:
+		return "Extend"
+	case _GraphemeGlue_After_Zwj:
+		return "Glue_After_Zwj"
+	case _GraphemeL:
+		return "L"
+	case _GraphemeLF:
+		return "LF"
+	case _GraphemeLV:
+		return "LV"
+	case _GraphemeLVT:
+		return "LVT"
+	case _GraphemePrepend:
+		return "Prepend"
+	case _GraphemeRegional_Indicator:
+		return "Regional_Indicator"
+	case _GraphemeSpacingMark:
+		return "SpacingMark"
+	case _GraphemeT:
+		return "T"
+	case _GraphemeV:
+		return "V"
+	case _GraphemeZWJ:
+		return "ZWJ"
+	default:
+		return "Other"
+	}
+}
+
+var _WordALetter = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x41, Hi: 0x5a, Stride: 0x1},
+		unicode.Range16{Lo: 0x61, Hi: 0x7a, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa, Hi: 0xaa, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5, Hi: 0xb5, Stride: 0x1},
+		unicode.Range16{Lo: 0xba, Hi: 0xba, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0, Hi: 0xd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xd8, Hi: 0xf6, Stride: 0x1},
+		unicode.Range16{Lo: 0xf8, Hi: 0x1ba, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bb, Hi: 0x1bb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bc, Hi: 0x1bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c0, Hi: 0x1c3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c4, Hi: 0x293, Stride: 0x1},
+		unicode.Range16{Lo: 0x294, Hi: 0x294, Stride: 0x1},
+		unicode.Range16{Lo: 0x295, Hi: 0x2af, Stride: 0x1},
+		unicode.Range16{Lo: 0x2b0, Hi: 0x2c1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6, Hi: 0x2d1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0, Hi: 0x2e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ec, Hi: 0x2ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ee, Hi: 0x2ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x370, Hi: 0x373, Stride: 0x1},
+		unicode.Range16{Lo: 0x374, Hi: 0x374, Stride: 0x1},
+		unicode.Range16{Lo: 0x376, Hi: 0x377, Stride: 0x1},
+		unicode.Range16{Lo: 0x37a, Hi: 0x37a, Stride: 0x1},
+		unicode.Range16{Lo: 0x37b, Hi: 0x37d, Stride: 0x1},
+		unicode.Range16{Lo: 0x37f, Hi: 0x37f, Stride: 0x1},
+		unicode.Range16{Lo: 0x386, Hi: 0x386, Stride: 0x1},
+		unicode.Range16{Lo: 0x388, Hi: 0x38a, Stride: 0x1},
+		unicode.Range16{Lo: 0x38c, Hi: 0x38c, Stride: 0x1},
+		unicode.Range16{Lo: 0x38e, Hi: 0x3a1, Stride: 0x1},
+		unicode.Range16{Lo: 0x3a3, Hi: 0x3f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f7, Hi: 0x481, Stride: 0x1},
+		unicode.Range16{Lo: 0x48a, Hi: 0x52f, Stride: 0x1},
+		unicode.Range16{Lo: 0x531, Hi: 0x556, Stride: 0x1},
+		unicode.Range16{Lo: 0x559, Hi: 0x559, Stride: 0x1},
+		unicode.Range16{Lo: 0x561, Hi: 0x587, Stride: 0x1},
+		unicode.Range16{Lo: 0x5f3, Hi: 0x5f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x620, Hi: 0x63f, Stride: 0x1},
+		unicode.Range16{Lo: 0x640, Hi: 0x640, Stride: 0x1},
+		unicode.Range16{Lo: 0x641, Hi: 0x64a, Stride: 0x1},
+		unicode.Range16{Lo: 0x66e, Hi: 0x66f, Stride: 0x1},
+		unicode.Range16{Lo: 0x671, Hi: 0x6d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d5, Hi: 0x6d5, Stride: 0x1},
+		unicode.Range16{Lo: 0x6e5, Hi: 0x6e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ee, Hi: 0x6ef, Stride: 0x1},
+		unicode.Range16{Lo: 0x6fa, Hi: 0x6fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ff, Hi: 0x6ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x710, Hi: 0x710, Stride: 0x1},
+		unicode.Range16{Lo: 0x712, Hi: 0x72f, Stride: 0x1},
+		unicode.Range16{Lo: 0x74d, Hi: 0x7a5, Stride: 0x1},
+		unicode.Range16{Lo: 0x7b1, Hi: 0x7b1, Stride: 0x1},
+		unicode.Range16{Lo: 0x7ca, Hi: 0x7ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f4, Hi: 0x7f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x7fa, Hi: 0x7fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x800, Hi: 0x815, Stride: 0x1},
+		unicode.Range16{Lo: 0x81a, Hi: 0x81a, Stride: 0x1},
+		unicode.Range16{Lo: 0x824, Hi: 0x824, Stride: 0x1},
+		unicode.Range16{Lo: 0x828, Hi: 0x828, Stride: 0x1},
+		unicode.Range16{Lo: 0x840, Hi: 0x858, Stride: 0x1},
+		unicode.Range16{Lo: 0x8a0, Hi: 0x8b4, Stride: 0x1},
+		unicode.Range16{Lo: 0x8b6, Hi: 0x8bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x904, Hi: 0x939, Stride: 0x1},
+		unicode.Range16{Lo: 0x93d, Hi: 0x93d, Stride: 0x1},
+		unicode.Range16{Lo: 0x950, Hi: 0x950, Stride: 0x1},
+		unicode.Range16{Lo: 0x958, Hi: 0x961, Stride: 0x1},
+		unicode.Range16{Lo: 0x971, Hi: 0x971, Stride: 0x1},
+		unicode.Range16{Lo: 0x972, Hi: 0x980, Stride: 0x1},
+		unicode.Range16{Lo: 0x985, Hi: 0x98c, Stride: 0x1},
+		unicode.Range16{Lo: 0x98f, Hi: 0x990, Stride: 0x1},
+		unicode.Range16{Lo: 0x993, Hi: 0x9a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x9aa, Hi: 0x9b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x9b2, Hi: 0x9b2, Stride: 0x1},
+		unicode.Range16{Lo: 0x9b6, Hi: 0x9b9, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bd, Hi: 0x9bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9ce, Hi: 0x9ce, Stride: 0x1},
+		unicode.Range16{Lo: 0x9dc, Hi: 0x9dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9df, Hi: 0x9e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x9f0, Hi: 0x9f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa05, Hi: 0xa0a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa0f, Hi: 0xa10, Stride: 0x1},
+		unicode.Range16{Lo: 0xa13, Hi: 0xa28, Stride: 0x1},
+		unicode.Range16{Lo: 0xa2a, Hi: 0xa30, Stride: 0x1},
+		unicode.Range16{Lo: 0xa32, Hi: 0xa33, Stride: 0x1},
+		unicode.Range16{Lo: 0xa35, Hi: 0xa36, Stride: 0x1},
+		unicode.Range16{Lo: 0xa38, Hi: 0xa39, Stride: 0x1},
+		unicode.Range16{Lo: 0xa59, Hi: 0xa5c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa5e, Hi: 0xa5e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72, Hi: 0xa74, Stride: 0x1},
+		unicode.Range16{Lo: 0xa85, Hi: 0xa8d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8f, Hi: 0xa91, Stride: 0x1},
+		unicode.Range16{Lo: 0xa93, Hi: 0xaa8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaa, Hi: 0xab0, Stride: 0x1},
+		unicode.Range16{Lo: 0xab2, Hi: 0xab3, Stride: 0x1},
+		unicode.Range16{Lo: 0xab5, Hi: 0xab9, Stride: 0x1},
+		unicode.Range16{Lo: 0xabd, Hi: 0xabd, Stride: 0x1},
+		unicode.Range16{Lo: 0xad0, Hi: 0xad0, Stride: 0x1},
+		unicode.Range16{Lo: 0xae0, Hi: 0xae1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf9, Hi: 0xaf9, Stride: 0x1},
+		unicode.Range16{Lo: 0xb05, Hi: 0xb0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0f, Hi: 0xb10, Stride: 0x1},
+		unicode.Range16{Lo: 0xb13, Hi: 0xb28, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2a, Hi: 0xb30, Stride: 0x1},
+		unicode.Range16{Lo: 0xb32, Hi: 0xb33, Stride: 0x1},
+		unicode.Range16{Lo: 0xb35, Hi: 0xb39, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3d, Hi: 0xb3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5c, Hi: 0xb5d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5f, Hi: 0xb61, Stride: 0x1},
+		unicode.Range16{Lo: 0xb71, Hi: 0xb71, Stride: 0x1},
+		unicode.Range16{Lo: 0xb83, Hi: 0xb83, Stride: 0x1},
+		unicode.Range16{Lo: 0xb85, Hi: 0xb8a, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8e, Hi: 0xb90, Stride: 0x1},
+		unicode.Range16{Lo: 0xb92, Hi: 0xb95, Stride: 0x1},
+		unicode.Range16{Lo: 0xb99, Hi: 0xb9a, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9c, Hi: 0xb9c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9e, Hi: 0xb9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xba3, Hi: 0xba4, Stride: 0x1},
+		unicode.Range16{Lo: 0xba8, Hi: 0xbaa, Stride: 0x1},
+		unicode.Range16{Lo: 0xbae, Hi: 0xbb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd0, Hi: 0xbd0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc05, Hi: 0xc0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0e, Hi: 0xc10, Stride: 0x1},
+		unicode.Range16{Lo: 0xc12, Hi: 0xc28, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2a, Hi: 0xc39, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3d, Hi: 0xc3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xc58, Hi: 0xc5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xc60, Hi: 0xc61, Stride: 0x1},
+		unicode.Range16{Lo: 0xc80, Hi: 0xc80, Stride: 0x1},
+		unicode.Range16{Lo: 0xc85, Hi: 0xc8c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8e, Hi: 0xc90, Stride: 0x1},
+		unicode.Range16{Lo: 0xc92, Hi: 0xca8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaa, Hi: 0xcb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb5, Hi: 0xcb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbd, Hi: 0xcbd, Stride: 0x1},
+		unicode.Range16{Lo: 0xcde, Hi: 0xcde, Stride: 0x1},
+		unicode.Range16{Lo: 0xce0, Hi: 0xce1, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf1, Hi: 0xcf2, Stride: 0x1},
+		unicode.Range16{Lo: 0xd05, Hi: 0xd0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0e, Hi: 0xd10, Stride: 0x1},
+		unicode.Range16{Lo: 0xd12, Hi: 0xd3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3d, Hi: 0xd3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4e, Hi: 0xd4e, Stride: 0x1},
+		unicode.Range16{Lo: 0xd54, Hi: 0xd56, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5f, Hi: 0xd61, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7a, Hi: 0xd7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd85, Hi: 0xd96, Stride: 0x1},
+		unicode.Range16{Lo: 0xd9a, Hi: 0xdb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xdb3, Hi: 0xdbb, Stride: 0x1},
+		unicode.Range16{Lo: 0xdbd, Hi: 0xdbd, Stride: 0x1},
+		unicode.Range16{Lo: 0xdc0, Hi: 0xdc6, Stride: 0x1},
+		unicode.Range16{Lo: 0xf00, Hi: 0xf00, Stride: 0x1},
+		unicode.Range16{Lo: 0xf40, Hi: 0xf47, Stride: 0x1},
+		unicode.Range16{Lo: 0xf49, Hi: 0xf6c, Stride: 0x1},
+		unicode.Range16{Lo: 0xf88, Hi: 0xf8c, Stride: 0x1},
+		unicode.Range16{Lo: 0x10a0, Hi: 0x10c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x10c7, Hi: 0x10c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x10cd, Hi: 0x10cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x10d0, Hi: 0x10fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x10fc, Hi: 0x10fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x10fd, Hi: 0x1248, Stride: 0x1},
+		unicode.Range16{Lo: 0x124a, Hi: 0x124d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1250, Hi: 0x1256, Stride: 0x1},
+		unicode.Range16{Lo: 0x1258, Hi: 0x1258, Stride: 0x1},
+		unicode.Range16{Lo: 0x125a, Hi: 0x125d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1260, Hi: 0x1288, Stride: 0x1},
+		unicode.Range16{Lo: 0x128a, Hi: 0x128d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1290, Hi: 0x12b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x12b2, Hi: 0x12b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x12b8, Hi: 0x12be, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c0, Hi: 0x12c0, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c2, Hi: 0x12c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c8, Hi: 0x12d6, Stride: 0x1},
+		unicode.Range16{Lo: 0x12d8, Hi: 0x1310, Stride: 0x1},
+		unicode.Range16{Lo: 0x1312, Hi: 0x1315, Stride: 0x1},
+		unicode.Range16{Lo: 0x1318, Hi: 0x135a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1380, Hi: 0x138f, Stride: 0x1},
+		unicode.Range16{Lo: 0x13a0, Hi: 0x13f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x13f8, Hi: 0x13fd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1401, Hi: 0x166c, Stride: 0x1},
+		unicode.Range16{Lo: 0x166f, Hi: 0x167f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1681, Hi: 0x169a, Stride: 0x1},
+		unicode.Range16{Lo: 0x16a0, Hi: 0x16ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x16ee, Hi: 0x16f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x16f1, Hi: 0x16f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1700, Hi: 0x170c, Stride: 0x1},
+		unicode.Range16{Lo: 0x170e, Hi: 0x1711, Stride: 0x1},
+		unicode.Range16{Lo: 0x1720, Hi: 0x1731, Stride: 0x1},
+		unicode.Range16{Lo: 0x1740, Hi: 0x1751, Stride: 0x1},
+		unicode.Range16{Lo: 0x1760, Hi: 0x176c, Stride: 0x1},
+		unicode.Range16{Lo: 0x176e, Hi: 0x1770, Stride: 0x1},
+		unicode.Range16{Lo: 0x1820, Hi: 0x1842, Stride: 0x1},
+		unicode.Range16{Lo: 0x1843, Hi: 0x1843, Stride: 0x1},
+		unicode.Range16{Lo: 0x1844, Hi: 0x1877, Stride: 0x1},
+		unicode.Range16{Lo: 0x1880, Hi: 0x1884, Stride: 0x1},
+		unicode.Range16{Lo: 0x1887, Hi: 0x18a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x18aa, Hi: 0x18aa, Stride: 0x1},
+		unicode.Range16{Lo: 0x18b0, Hi: 0x18f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1900, Hi: 0x191e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a00, Hi: 0x1a16, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b05, Hi: 0x1b33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b45, Hi: 0x1b4b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b83, Hi: 0x1ba0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bae, Hi: 0x1baf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bba, Hi: 0x1be5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c00, Hi: 0x1c23, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c4d, Hi: 0x1c4f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c5a, Hi: 0x1c77, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c78, Hi: 0x1c7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c80, Hi: 0x1c88, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce9, Hi: 0x1cec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cee, Hi: 0x1cf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf5, Hi: 0x1cf6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d00, Hi: 0x1d2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d2c, Hi: 0x1d6a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d6b, Hi: 0x1d77, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d78, Hi: 0x1d78, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d79, Hi: 0x1d9a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d9b, Hi: 0x1dbf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e00, Hi: 0x1f15, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f18, Hi: 0x1f1d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f20, Hi: 0x1f45, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f48, Hi: 0x1f4d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f50, Hi: 0x1f57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f59, Hi: 0x1f59, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5b, Hi: 0x1f5b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5d, Hi: 0x1f5d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5f, Hi: 0x1f7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f80, Hi: 0x1fb4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fb6, Hi: 0x1fbc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fbe, Hi: 0x1fbe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc2, Hi: 0x1fc4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc6, Hi: 0x1fcc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd0, Hi: 0x1fd3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd6, Hi: 0x1fdb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fe0, Hi: 0x1fec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff2, Hi: 0x1ff4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff6, Hi: 0x1ffc, Stride: 0x1},
+		unicode.Range16{Lo: 0x2071, Hi: 0x2071, Stride: 0x1},
+		unicode.Range16{Lo: 0x207f, Hi: 0x207f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2090, Hi: 0x209c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2102, Hi: 0x2102, Stride: 0x1},
+		unicode.Range16{Lo: 0x2107, Hi: 0x2107, Stride: 0x1},
+		unicode.Range16{Lo: 0x210a, Hi: 0x2113, Stride: 0x1},
+		unicode.Range16{Lo: 0x2115, Hi: 0x2115, Stride: 0x1},
+		unicode.Range16{Lo: 0x2119, Hi: 0x211d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2124, Hi: 0x2124, Stride: 0x1},
+		unicode.Range16{Lo: 0x2126, Hi: 0x2126, Stride: 0x1},
+		unicode.Range16{Lo: 0x2128, Hi: 0x2128, Stride: 0x1},
+		unicode.Range16{Lo: 0x212a, Hi: 0x212d, Stride: 0x1},
+		unicode.Range16{Lo: 0x212f, Hi: 0x2134, Stride: 0x1},
+		unicode.Range16{Lo: 0x2135, Hi: 0x2138, Stride: 0x1},
+		unicode.Range16{Lo: 0x2139, Hi: 0x2139, Stride: 0x1},
+		unicode.Range16{Lo: 0x213c, Hi: 0x213f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2145, Hi: 0x2149, Stride: 0x1},
+		unicode.Range16{Lo: 0x214e, Hi: 0x214e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2160, Hi: 0x2182, Stride: 0x1},
+		unicode.Range16{Lo: 0x2183, Hi: 0x2184, Stride: 0x1},
+		unicode.Range16{Lo: 0x2185, Hi: 0x2188, Stride: 0x1},
+		unicode.Range16{Lo: 0x24b6, Hi: 0x24e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c00, Hi: 0x2c2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c30, Hi: 0x2c5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c60, Hi: 0x2c7b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c7c, Hi: 0x2c7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c7e, Hi: 0x2ce4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ceb, Hi: 0x2cee, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cf2, Hi: 0x2cf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d00, Hi: 0x2d25, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d27, Hi: 0x2d27, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d2d, Hi: 0x2d2d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d30, Hi: 0x2d67, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d6f, Hi: 0x2d6f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d80, Hi: 0x2d96, Stride: 0x1},
+		unicode.Range16{Lo: 0x2da0, Hi: 0x2da6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2da8, Hi: 0x2dae, Stride: 0x1},
+		unicode.Range16{Lo: 0x2db0, Hi: 0x2db6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2db8, Hi: 0x2dbe, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dc0, Hi: 0x2dc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dc8, Hi: 0x2dce, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dd0, Hi: 0x2dd6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dd8, Hi: 0x2dde, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e2f, Hi: 0x2e2f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3005, Hi: 0x3005, Stride: 0x1},
+		unicode.Range16{Lo: 0x303b, Hi: 0x303b, Stride: 0x1},
+		unicode.Range16{Lo: 0x303c, Hi: 0x303c, Stride: 0x1},
+		unicode.Range16{Lo: 0x3105, Hi: 0x312d, Stride: 0x1},
+		unicode.Range16{Lo: 0x3131, Hi: 0x318e, Stride: 0x1},
+		unicode.Range16{Lo: 0x31a0, Hi: 0x31ba, Stride: 0x1},
+		unicode.Range16{Lo: 0xa000, Hi: 0xa014, Stride: 0x1},
+		unicode.Range16{Lo: 0xa015, Hi: 0xa015, Stride: 0x1},
+		unicode.Range16{Lo: 0xa016, Hi: 0xa48c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4d0, Hi: 0xa4f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4f8, Hi: 0xa4fd, Stride: 0x1},
+		unicode.Range16{Lo: 0xa500, Hi: 0xa60b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa60c, Hi: 0xa60c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa610, Hi: 0xa61f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa62a, Hi: 0xa62b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa640, Hi: 0xa66d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66e, Hi: 0xa66e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa67f, Hi: 0xa67f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa680, Hi: 0xa69b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69c, Hi: 0xa69d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6a0, Hi: 0xa6e5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6e6, Hi: 0xa6ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xa717, Hi: 0xa71f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa722, Hi: 0xa76f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa770, Hi: 0xa770, Stride: 0x1},
+		unicode.Range16{Lo: 0xa771, Hi: 0xa787, Stride: 0x1},
+		unicode.Range16{Lo: 0xa788, Hi: 0xa788, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78b, Hi: 0xa78e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78f, Hi: 0xa78f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa790, Hi: 0xa7ae, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7b0, Hi: 0xa7b7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7f7, Hi: 0xa7f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7f8, Hi: 0xa7f9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7fa, Hi: 0xa7fa, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7fb, Hi: 0xa801, Stride: 0x1},
+		unicode.Range16{Lo: 0xa803, Hi: 0xa805, Stride: 0x1},
+		unicode.Range16{Lo: 0xa807, Hi: 0xa80a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa80c, Hi: 0xa822, Stride: 0x1},
+		unicode.Range16{Lo: 0xa840, Hi: 0xa873, Stride: 0x1},
+		unicode.Range16{Lo: 0xa882, Hi: 0xa8b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8f2, Hi: 0xa8f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8fb, Hi: 0xa8fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8fd, Hi: 0xa8fd, Stride: 0x1},
+		unicode.Range16{Lo: 0xa90a, Hi: 0xa925, Stride: 0x1},
+		unicode.Range16{Lo: 0xa930, Hi: 0xa946, Stride: 0x1},
+		unicode.Range16{Lo: 0xa960, Hi: 0xa97c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa984, Hi: 0xa9b2, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9cf, Hi: 0xa9cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa00, Hi: 0xaa28, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa40, Hi: 0xaa42, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa44, Hi: 0xaa4b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaae0, Hi: 0xaaea, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf2, Hi: 0xaaf2, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf3, Hi: 0xaaf4, Stride: 0x1},
+		unicode.Range16{Lo: 0xab01, Hi: 0xab06, Stride: 0x1},
+		unicode.Range16{Lo: 0xab09, Hi: 0xab0e, Stride: 0x1},
+		unicode.Range16{Lo: 0xab11, Hi: 0xab16, Stride: 0x1},
+		unicode.Range16{Lo: 0xab20, Hi: 0xab26, Stride: 0x1},
+		unicode.Range16{Lo: 0xab28, Hi: 0xab2e, Stride: 0x1},
+		unicode.Range16{Lo: 0xab30, Hi: 0xab5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xab5c, Hi: 0xab5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xab60, Hi: 0xab65, Stride: 0x1},
+		unicode.Range16{Lo: 0xab70, Hi: 0xabbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xabc0, Hi: 0xabe2, Stride: 0x1},
+		unicode.Range16{Lo: 0xac00, Hi: 0xd7a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7b0, Hi: 0xd7c6, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7cb, Hi: 0xd7fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb00, Hi: 0xfb06, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb13, Hi: 0xfb17, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb50, Hi: 0xfbb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xfbd3, Hi: 0xfd3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd50, Hi: 0xfd8f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd92, Hi: 0xfdc7, Stride: 0x1},
+		unicode.Range16{Lo: 0xfdf0, Hi: 0xfdfb, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe70, Hi: 0xfe74, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe76, Hi: 0xfefc, Stride: 0x1},
+		unicode.Range16{Lo: 0xff21, Hi: 0xff3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xff41, Hi: 0xff5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xffa0, Hi: 0xffbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xffc2, Hi: 0xffc7, Stride: 0x1},
+		unicode.Range16{Lo: 0xffca, Hi: 0xffcf, Stride: 0x1},
+		unicode.Range16{Lo: 0xffd2, Hi: 0xffd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xffda, Hi: 0xffdc, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x10000, Hi: 0x1000b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1000d, Hi: 0x10026, Stride: 0x1},
+		unicode.Range32{Lo: 0x10028, Hi: 0x1003a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1003c, Hi: 0x1003d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1003f, Hi: 0x1004d, Stride: 0x1},
+		unicode.Range32{Lo: 0x10050, Hi: 0x1005d, Stride: 0x1},
+		unicode.Range32{Lo: 0x10080, Hi: 0x100fa, Stride: 0x1},
+		unicode.Range32{Lo: 0x10140, Hi: 0x10174, Stride: 0x1},
+		unicode.Range32{Lo: 0x10280, Hi: 0x1029c, Stride: 0x1},
+		unicode.Range32{Lo: 0x102a0, Hi: 0x102d0, Stride: 0x1},
+		unicode.Range32{Lo: 0x10300, Hi: 0x1031f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10330, Hi: 0x10340, Stride: 0x1},
+		unicode.Range32{Lo: 0x10341, Hi: 0x10341, Stride: 0x1},
+		unicode.Range32{Lo: 0x10342, Hi: 0x10349, Stride: 0x1},
+		unicode.Range32{Lo: 0x1034a, Hi: 0x1034a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10350, Hi: 0x10375, Stride: 0x1},
+		unicode.Range32{Lo: 0x10380, Hi: 0x1039d, Stride: 0x1},
+		unicode.Range32{Lo: 0x103a0, Hi: 0x103c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x103c8, Hi: 0x103cf, Stride: 0x1},
+		unicode.Range32{Lo: 0x103d1, Hi: 0x103d5, Stride: 0x1},
+		unicode.Range32{Lo: 0x10400, Hi: 0x1044f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10450, Hi: 0x1049d, Stride: 0x1},
+		unicode.Range32{Lo: 0x104b0, Hi: 0x104d3, Stride: 0x1},
+		unicode.Range32{Lo: 0x104d8, Hi: 0x104fb, Stride: 0x1},
+		unicode.Range32{Lo: 0x10500, Hi: 0x10527, Stride: 0x1},
+		unicode.Range32{Lo: 0x10530, Hi: 0x10563, Stride: 0x1},
+		unicode.Range32{Lo: 0x10600, Hi: 0x10736, Stride: 0x1},
+		unicode.Range32{Lo: 0x10740, Hi: 0x10755, Stride: 0x1},
+		unicode.Range32{Lo: 0x10760, Hi: 0x10767, Stride: 0x1},
+		unicode.Range32{Lo: 0x10800, Hi: 0x10805, Stride: 0x1},
+		unicode.Range32{Lo: 0x10808, Hi: 0x10808, Stride: 0x1},
+		unicode.Range32{Lo: 0x1080a, Hi: 0x10835, Stride: 0x1},
+		unicode.Range32{Lo: 0x10837, Hi: 0x10838, Stride: 0x1},
+		unicode.Range32{Lo: 0x1083c, Hi: 0x1083c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1083f, Hi: 0x10855, Stride: 0x1},
+		unicode.Range32{Lo: 0x10860, Hi: 0x10876, Stride: 0x1},
+		unicode.Range32{Lo: 0x10880, Hi: 0x1089e, Stride: 0x1},
+		unicode.Range32{Lo: 0x108e0, Hi: 0x108f2, Stride: 0x1},
+		unicode.Range32{Lo: 0x108f4, Hi: 0x108f5, Stride: 0x1},
+		unicode.Range32{Lo: 0x10900, Hi: 0x10915, Stride: 0x1},
+		unicode.Range32{Lo: 0x10920, Hi: 0x10939, Stride: 0x1},
+		unicode.Range32{Lo: 0x10980, Hi: 0x109b7, Stride: 0x1},
+		unicode.Range32{Lo: 0x109be, Hi: 0x109bf, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a00, Hi: 0x10a00, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a10, Hi: 0x10a13, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a15, Hi: 0x10a17, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a19, Hi: 0x10a33, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a60, Hi: 0x10a7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a80, Hi: 0x10a9c, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ac0, Hi: 0x10ac7, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ac9, Hi: 0x10ae4, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b00, Hi: 0x10b35, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b40, Hi: 0x10b55, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b60, Hi: 0x10b72, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b80, Hi: 0x10b91, Stride: 0x1},
+		unicode.Range32{Lo: 0x10c00, Hi: 0x10c48, Stride: 0x1},
+		unicode.Range32{Lo: 0x10c80, Hi: 0x10cb2, Stride: 0x1},
+		unicode.Range32{Lo: 0x10cc0, Hi: 0x10cf2, Stride: 0x1},
+		unicode.Range32{Lo: 0x11003, Hi: 0x11037, Stride: 0x1},
+		unicode.Range32{Lo: 0x11083, Hi: 0x110af, Stride: 0x1},
+		unicode.Range32{Lo: 0x110d0, Hi: 0x110e8, Stride: 0x1},
+		unicode.Range32{Lo: 0x11103, Hi: 0x11126, Stride: 0x1},
+		unicode.Range32{Lo: 0x11150, Hi: 0x11172, Stride: 0x1},
+		unicode.Range32{Lo: 0x11176, Hi: 0x11176, Stride: 0x1},
+		unicode.Range32{Lo: 0x11183, Hi: 0x111b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x111c1, Hi: 0x111c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x111da, Hi: 0x111da, Stride: 0x1},
+		unicode.Range32{Lo: 0x111dc, Hi: 0x111dc, Stride: 0x1},
+		unicode.Range32{Lo: 0x11200, Hi: 0x11211, Stride: 0x1},
+		unicode.Range32{Lo: 0x11213, Hi: 0x1122b, Stride: 0x1},
+		unicode.Range32{Lo: 0x11280, Hi: 0x11286, Stride: 0x1},
+		unicode.Range32{Lo: 0x11288, Hi: 0x11288, Stride: 0x1},
+		unicode.Range32{Lo: 0x1128a, Hi: 0x1128d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1128f, Hi: 0x1129d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1129f, Hi: 0x112a8, Stride: 0x1},
+		unicode.Range32{Lo: 0x112b0, Hi: 0x112de, Stride: 0x1},
+		unicode.Range32{Lo: 0x11305, Hi: 0x1130c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1130f, Hi: 0x11310, Stride: 0x1},
+		unicode.Range32{Lo: 0x11313, Hi: 0x11328, Stride: 0x1},
+		unicode.Range32{Lo: 0x1132a, Hi: 0x11330, Stride: 0x1},
+		unicode.Range32{Lo: 0x11332, Hi: 0x11333, Stride: 0x1},
+		unicode.Range32{Lo: 0x11335, Hi: 0x11339, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133d, Hi: 0x1133d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11350, Hi: 0x11350, Stride: 0x1},
+		unicode.Range32{Lo: 0x1135d, Hi: 0x11361, Stride: 0x1},
+		unicode.Range32{Lo: 0x11400, Hi: 0x11434, Stride: 0x1},
+		unicode.Range32{Lo: 0x11447, Hi: 0x1144a, Stride: 0x1},
+		unicode.Range32{Lo: 0x11480, Hi: 0x114af, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c4, Hi: 0x114c5, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c7, Hi: 0x114c7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11580, Hi: 0x115ae, Stride: 0x1},
+		unicode.Range32{Lo: 0x115d8, Hi: 0x115db, Stride: 0x1},
+		unicode.Range32{Lo: 0x11600, Hi: 0x1162f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11644, Hi: 0x11644, Stride: 0x1},
+		unicode.Range32{Lo: 0x11680, Hi: 0x116aa, Stride: 0x1},
+		unicode.Range32{Lo: 0x118a0, Hi: 0x118df, Stride: 0x1},
+		unicode.Range32{Lo: 0x118ff, Hi: 0x118ff, Stride: 0x1},
+		unicode.Range32{Lo: 0x11ac0, Hi: 0x11af8, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c00, Hi: 0x11c08, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c0a, Hi: 0x11c2e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c40, Hi: 0x11c40, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c72, Hi: 0x11c8f, Stride: 0x1},
+		unicode.Range32{Lo: 0x12000, Hi: 0x12399, Stride: 0x1},
+		unicode.Range32{Lo: 0x12400, Hi: 0x1246e, Stride: 0x1},
+		unicode.Range32{Lo: 0x12480, Hi: 0x12543, Stride: 0x1},
+		unicode.Range32{Lo: 0x13000, Hi: 0x1342e, Stride: 0x1},
+		unicode.Range32{Lo: 0x14400, Hi: 0x14646, Stride: 0x1},
+		unicode.Range32{Lo: 0x16800, Hi: 0x16a38, Stride: 0x1},
+		unicode.Range32{Lo: 0x16a40, Hi: 0x16a5e, Stride: 0x1},
+		unicode.Range32{Lo: 0x16ad0, Hi: 0x16aed, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b00, Hi: 0x16b2f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b40, Hi: 0x16b43, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b63, Hi: 0x16b77, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b7d, Hi: 0x16b8f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f00, Hi: 0x16f44, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f50, Hi: 0x16f50, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f93, Hi: 0x16f9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16fe0, Hi: 0x16fe0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc00, Hi: 0x1bc6a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc70, Hi: 0x1bc7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc80, Hi: 0x1bc88, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc90, Hi: 0x1bc99, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d400, Hi: 0x1d454, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d456, Hi: 0x1d49c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d49e, Hi: 0x1d49f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a2, Hi: 0x1d4a2, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a5, Hi: 0x1d4a6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a9, Hi: 0x1d4ac, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4ae, Hi: 0x1d4b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4bb, Hi: 0x1d4bb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4bd, Hi: 0x1d4c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4c5, Hi: 0x1d505, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d507, Hi: 0x1d50a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d50d, Hi: 0x1d514, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d516, Hi: 0x1d51c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d51e, Hi: 0x1d539, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d53b, Hi: 0x1d53e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d540, Hi: 0x1d544, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d546, Hi: 0x1d546, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d54a, Hi: 0x1d550, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d552, Hi: 0x1d6a5, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6a8, Hi: 0x1d6c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6c2, Hi: 0x1d6da, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6dc, Hi: 0x1d6fa, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6fc, Hi: 0x1d714, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d716, Hi: 0x1d734, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d736, Hi: 0x1d74e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d750, Hi: 0x1d76e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d770, Hi: 0x1d788, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d78a, Hi: 0x1d7a8, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7aa, Hi: 0x1d7c2, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7c4, Hi: 0x1d7cb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e800, Hi: 0x1e8c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e900, Hi: 0x1e943, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee00, Hi: 0x1ee03, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee05, Hi: 0x1ee1f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee21, Hi: 0x1ee22, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee24, Hi: 0x1ee24, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee27, Hi: 0x1ee27, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee29, Hi: 0x1ee32, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee34, Hi: 0x1ee37, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee39, Hi: 0x1ee39, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee3b, Hi: 0x1ee3b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee42, Hi: 0x1ee42, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee47, Hi: 0x1ee47, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee49, Hi: 0x1ee49, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee4b, Hi: 0x1ee4b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee4d, Hi: 0x1ee4f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee51, Hi: 0x1ee52, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee54, Hi: 0x1ee54, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee57, Hi: 0x1ee57, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee59, Hi: 0x1ee59, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5b, Hi: 0x1ee5b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5d, Hi: 0x1ee5d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5f, Hi: 0x1ee5f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee61, Hi: 0x1ee62, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee64, Hi: 0x1ee64, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee67, Hi: 0x1ee6a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee6c, Hi: 0x1ee72, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee74, Hi: 0x1ee77, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee79, Hi: 0x1ee7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee7e, Hi: 0x1ee7e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee80, Hi: 0x1ee89, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee8b, Hi: 0x1ee9b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eea1, Hi: 0x1eea3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eea5, Hi: 0x1eea9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eeab, Hi: 0x1eebb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f130, Hi: 0x1f149, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f150, Hi: 0x1f169, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f170, Hi: 0x1f189, Stride: 0x1},
+	},
+	LatinOffset: 7,
+}
+
+var _WordCR = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xd, Hi: 0xd, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordDouble_Quote = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x22, Hi: 0x22, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordE_Base = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x261d, Hi: 0x261d, Stride: 0x1},
+		unicode.Range16{Lo: 0x26f9, Hi: 0x26f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x270a, Hi: 0x270d, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f385, Hi: 0x1f385, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f3c3, Hi: 0x1f3c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f3ca, Hi: 0x1f3cb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f442, Hi: 0x1f443, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f446, Hi: 0x1f450, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f46e, Hi: 0x1f46e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f470, Hi: 0x1f478, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f47c, Hi: 0x1f47c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f481, Hi: 0x1f483, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f485, Hi: 0x1f487, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f4aa, Hi: 0x1f4aa, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f575, Hi: 0x1f575, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f57a, Hi: 0x1f57a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f590, Hi: 0x1f590, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f595, Hi: 0x1f596, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f645, Hi: 0x1f647, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f64b, Hi: 0x1f64f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6a3, Hi: 0x1f6a3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6b4, Hi: 0x1f6b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f6c0, Hi: 0x1f6c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f918, Hi: 0x1f91e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f926, Hi: 0x1f926, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f930, Hi: 0x1f930, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f933, Hi: 0x1f939, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f93c, Hi: 0x1f93e, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordE_Base_GAZ = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f466, Hi: 0x1f469, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordE_Modifier = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f3fb, Hi: 0x1f3ff, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordExtend = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x300, Hi: 0x36f, Stride: 0x1},
+		unicode.Range16{Lo: 0x483, Hi: 0x487, Stride: 0x1},
+		unicode.Range16{Lo: 0x488, Hi: 0x489, Stride: 0x1},
+		unicode.Range16{Lo: 0x591, Hi: 0x5bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x5bf, Hi: 0x5bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c1, Hi: 0x5c2, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c4, Hi: 0x5c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c7, Hi: 0x5c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x610, Hi: 0x61a, Stride: 0x1},
+		unicode.Range16{Lo: 0x64b, Hi: 0x65f, Stride: 0x1},
+		unicode.Range16{Lo: 0x670, Hi: 0x670, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d6, Hi: 0x6dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x6df, Hi: 0x6e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x6e7, Hi: 0x6e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ea, Hi: 0x6ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x711, Hi: 0x711, Stride: 0x1},
+		unicode.Range16{Lo: 0x730, Hi: 0x74a, Stride: 0x1},
+		unicode.Range16{Lo: 0x7a6, Hi: 0x7b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x7eb, Hi: 0x7f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x816, Hi: 0x819, Stride: 0x1},
+		unicode.Range16{Lo: 0x81b, Hi: 0x823, Stride: 0x1},
+		unicode.Range16{Lo: 0x825, Hi: 0x827, Stride: 0x1},
+		unicode.Range16{Lo: 0x829, Hi: 0x82d, Stride: 0x1},
+		unicode.Range16{Lo: 0x859, Hi: 0x85b, Stride: 0x1},
+		unicode.Range16{Lo: 0x8d4, Hi: 0x8e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e3, Hi: 0x902, Stride: 0x1},
+		unicode.Range16{Lo: 0x903, Hi: 0x903, Stride: 0x1},
+		unicode.Range16{Lo: 0x93a, Hi: 0x93a, Stride: 0x1},
+		unicode.Range16{Lo: 0x93b, Hi: 0x93b, Stride: 0x1},
+		unicode.Range16{Lo: 0x93c, Hi: 0x93c, Stride: 0x1},
+		unicode.Range16{Lo: 0x93e, Hi: 0x940, Stride: 0x1},
+		unicode.Range16{Lo: 0x941, Hi: 0x948, Stride: 0x1},
+		unicode.Range16{Lo: 0x949, Hi: 0x94c, Stride: 0x1},
+		unicode.Range16{Lo: 0x94d, Hi: 0x94d, Stride: 0x1},
+		unicode.Range16{Lo: 0x94e, Hi: 0x94f, Stride: 0x1},
+		unicode.Range16{Lo: 0x951, Hi: 0x957, Stride: 0x1},
+		unicode.Range16{Lo: 0x962, Hi: 0x963, Stride: 0x1},
+		unicode.Range16{Lo: 0x981, Hi: 0x981, Stride: 0x1},
+		unicode.Range16{Lo: 0x982, Hi: 0x983, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bc, Hi: 0x9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0x9be, Hi: 0x9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c1, Hi: 0x9c4, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c7, Hi: 0x9c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cb, Hi: 0x9cc, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cd, Hi: 0x9cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9d7, Hi: 0x9d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x9e2, Hi: 0x9e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa01, Hi: 0xa02, Stride: 0x1},
+		unicode.Range16{Lo: 0xa03, Hi: 0xa03, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3c, Hi: 0xa3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3e, Hi: 0xa40, Stride: 0x1},
+		unicode.Range16{Lo: 0xa41, Hi: 0xa42, Stride: 0x1},
+		unicode.Range16{Lo: 0xa47, Hi: 0xa48, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4b, Hi: 0xa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa51, Hi: 0xa51, Stride: 0x1},
+		unicode.Range16{Lo: 0xa70, Hi: 0xa71, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75, Hi: 0xa75, Stride: 0x1},
+		unicode.Range16{Lo: 0xa81, Hi: 0xa82, Stride: 0x1},
+		unicode.Range16{Lo: 0xa83, Hi: 0xa83, Stride: 0x1},
+		unicode.Range16{Lo: 0xabc, Hi: 0xabc, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe, Hi: 0xac0, Stride: 0x1},
+		unicode.Range16{Lo: 0xac1, Hi: 0xac5, Stride: 0x1},
+		unicode.Range16{Lo: 0xac7, Hi: 0xac8, Stride: 0x1},
+		unicode.Range16{Lo: 0xac9, Hi: 0xac9, Stride: 0x1},
+		unicode.Range16{Lo: 0xacb, Hi: 0xacc, Stride: 0x1},
+		unicode.Range16{Lo: 0xacd, Hi: 0xacd, Stride: 0x1},
+		unicode.Range16{Lo: 0xae2, Hi: 0xae3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb01, Hi: 0xb01, Stride: 0x1},
+		unicode.Range16{Lo: 0xb02, Hi: 0xb03, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3c, Hi: 0xb3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3e, Hi: 0xb3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3f, Hi: 0xb3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb40, Hi: 0xb40, Stride: 0x1},
+		unicode.Range16{Lo: 0xb41, Hi: 0xb44, Stride: 0x1},
+		unicode.Range16{Lo: 0xb47, Hi: 0xb48, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4b, Hi: 0xb4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4d, Hi: 0xb4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb56, Hi: 0xb56, Stride: 0x1},
+		unicode.Range16{Lo: 0xb57, Hi: 0xb57, Stride: 0x1},
+		unicode.Range16{Lo: 0xb62, Hi: 0xb63, Stride: 0x1},
+		unicode.Range16{Lo: 0xb82, Hi: 0xb82, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbe, Hi: 0xbbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc0, Hi: 0xbc0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc1, Hi: 0xbc2, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc6, Hi: 0xbc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbca, Hi: 0xbcc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcd, Hi: 0xbcd, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd7, Hi: 0xbd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc00, Hi: 0xc00, Stride: 0x1},
+		unicode.Range16{Lo: 0xc01, Hi: 0xc03, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3e, Hi: 0xc40, Stride: 0x1},
+		unicode.Range16{Lo: 0xc41, Hi: 0xc44, Stride: 0x1},
+		unicode.Range16{Lo: 0xc46, Hi: 0xc48, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4a, Hi: 0xc4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xc55, Hi: 0xc56, Stride: 0x1},
+		unicode.Range16{Lo: 0xc62, Hi: 0xc63, Stride: 0x1},
+		unicode.Range16{Lo: 0xc81, Hi: 0xc81, Stride: 0x1},
+		unicode.Range16{Lo: 0xc82, Hi: 0xc83, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbc, Hi: 0xcbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbe, Hi: 0xcbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbf, Hi: 0xcbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc0, Hi: 0xcc4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc6, Hi: 0xcc6, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc7, Hi: 0xcc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcca, Hi: 0xccb, Stride: 0x1},
+		unicode.Range16{Lo: 0xccc, Hi: 0xccd, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd5, Hi: 0xcd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xce2, Hi: 0xce3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd01, Hi: 0xd01, Stride: 0x1},
+		unicode.Range16{Lo: 0xd02, Hi: 0xd03, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3e, Hi: 0xd40, Stride: 0x1},
+		unicode.Range16{Lo: 0xd41, Hi: 0xd44, Stride: 0x1},
+		unicode.Range16{Lo: 0xd46, Hi: 0xd48, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4a, Hi: 0xd4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4d, Hi: 0xd4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xd57, Hi: 0xd57, Stride: 0x1},
+		unicode.Range16{Lo: 0xd62, Hi: 0xd63, Stride: 0x1},
+		unicode.Range16{Lo: 0xd82, Hi: 0xd83, Stride: 0x1},
+		unicode.Range16{Lo: 0xdca, Hi: 0xdca, Stride: 0x1},
+		unicode.Range16{Lo: 0xdcf, Hi: 0xdd1, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd2, Hi: 0xdd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd6, Hi: 0xdd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd8, Hi: 0xddf, Stride: 0x1},
+		unicode.Range16{Lo: 0xdf2, Hi: 0xdf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xe31, Hi: 0xe31, Stride: 0x1},
+		unicode.Range16{Lo: 0xe34, Hi: 0xe3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xe47, Hi: 0xe4e, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb1, Hi: 0xeb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb4, Hi: 0xeb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xebb, Hi: 0xebc, Stride: 0x1},
+		unicode.Range16{Lo: 0xec8, Hi: 0xecd, Stride: 0x1},
+		unicode.Range16{Lo: 0xf18, Hi: 0xf19, Stride: 0x1},
+		unicode.Range16{Lo: 0xf35, Hi: 0xf35, Stride: 0x1},
+		unicode.Range16{Lo: 0xf37, Hi: 0xf37, Stride: 0x1},
+		unicode.Range16{Lo: 0xf39, Hi: 0xf39, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3e, Hi: 0xf3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xf71, Hi: 0xf7e, Stride: 0x1},
+		unicode.Range16{Lo: 0xf7f, Hi: 0xf7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xf80, Hi: 0xf84, Stride: 0x1},
+		unicode.Range16{Lo: 0xf86, Hi: 0xf87, Stride: 0x1},
+		unicode.Range16{Lo: 0xf8d, Hi: 0xf97, Stride: 0x1},
+		unicode.Range16{Lo: 0xf99, Hi: 0xfbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xfc6, Hi: 0xfc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x102b, Hi: 0x102c, Stride: 0x1},
+		unicode.Range16{Lo: 0x102d, Hi: 0x1030, Stride: 0x1},
+		unicode.Range16{Lo: 0x1031, Hi: 0x1031, Stride: 0x1},
+		unicode.Range16{Lo: 0x1032, Hi: 0x1037, Stride: 0x1},
+		unicode.Range16{Lo: 0x1038, Hi: 0x1038, Stride: 0x1},
+		unicode.Range16{Lo: 0x1039, Hi: 0x103a, Stride: 0x1},
+		unicode.Range16{Lo: 0x103b, Hi: 0x103c, Stride: 0x1},
+		unicode.Range16{Lo: 0x103d, Hi: 0x103e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1056, Hi: 0x1057, Stride: 0x1},
+		unicode.Range16{Lo: 0x1058, Hi: 0x1059, Stride: 0x1},
+		unicode.Range16{Lo: 0x105e, Hi: 0x1060, Stride: 0x1},
+		unicode.Range16{Lo: 0x1062, Hi: 0x1064, Stride: 0x1},
+		unicode.Range16{Lo: 0x1067, Hi: 0x106d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1071, Hi: 0x1074, Stride: 0x1},
+		unicode.Range16{Lo: 0x1082, Hi: 0x1082, Stride: 0x1},
+		unicode.Range16{Lo: 0x1083, Hi: 0x1084, Stride: 0x1},
+		unicode.Range16{Lo: 0x1085, Hi: 0x1086, Stride: 0x1},
+		unicode.Range16{Lo: 0x1087, Hi: 0x108c, Stride: 0x1},
+		unicode.Range16{Lo: 0x108d, Hi: 0x108d, Stride: 0x1},
+		unicode.Range16{Lo: 0x108f, Hi: 0x108f, Stride: 0x1},
+		unicode.Range16{Lo: 0x109a, Hi: 0x109c, Stride: 0x1},
+		unicode.Range16{Lo: 0x109d, Hi: 0x109d, Stride: 0x1},
+		unicode.Range16{Lo: 0x135d, Hi: 0x135f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1712, Hi: 0x1714, Stride: 0x1},
+		unicode.Range16{Lo: 0x1732, Hi: 0x1734, Stride: 0x1},
+		unicode.Range16{Lo: 0x1752, Hi: 0x1753, Stride: 0x1},
+		unicode.Range16{Lo: 0x1772, Hi: 0x1773, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b4, Hi: 0x17b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b6, Hi: 0x17b6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b7, Hi: 0x17bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x17be, Hi: 0x17c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c6, Hi: 0x17c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c7, Hi: 0x17c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c9, Hi: 0x17d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x17dd, Hi: 0x17dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x180b, Hi: 0x180d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1885, Hi: 0x1886, Stride: 0x1},
+		unicode.Range16{Lo: 0x18a9, Hi: 0x18a9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1920, Hi: 0x1922, Stride: 0x1},
+		unicode.Range16{Lo: 0x1923, Hi: 0x1926, Stride: 0x1},
+		unicode.Range16{Lo: 0x1927, Hi: 0x1928, Stride: 0x1},
+		unicode.Range16{Lo: 0x1929, Hi: 0x192b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1930, Hi: 0x1931, Stride: 0x1},
+		unicode.Range16{Lo: 0x1932, Hi: 0x1932, Stride: 0x1},
+		unicode.Range16{Lo: 0x1933, Hi: 0x1938, Stride: 0x1},
+		unicode.Range16{Lo: 0x1939, Hi: 0x193b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a17, Hi: 0x1a18, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a19, Hi: 0x1a1a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a1b, Hi: 0x1a1b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a55, Hi: 0x1a55, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a56, Hi: 0x1a56, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a57, Hi: 0x1a57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a58, Hi: 0x1a5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a60, Hi: 0x1a60, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a61, Hi: 0x1a61, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a62, Hi: 0x1a62, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a63, Hi: 0x1a64, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a65, Hi: 0x1a6c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a6d, Hi: 0x1a72, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a73, Hi: 0x1a7c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a7f, Hi: 0x1a7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ab0, Hi: 0x1abd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1abe, Hi: 0x1abe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b00, Hi: 0x1b03, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b04, Hi: 0x1b04, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b34, Hi: 0x1b34, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b35, Hi: 0x1b35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b36, Hi: 0x1b3a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3b, Hi: 0x1b3b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3c, Hi: 0x1b3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3d, Hi: 0x1b41, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b42, Hi: 0x1b42, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b43, Hi: 0x1b44, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b6b, Hi: 0x1b73, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b80, Hi: 0x1b81, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b82, Hi: 0x1b82, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba1, Hi: 0x1ba1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba2, Hi: 0x1ba5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba6, Hi: 0x1ba7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba8, Hi: 0x1ba9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1baa, Hi: 0x1baa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bab, Hi: 0x1bad, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be6, Hi: 0x1be6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be7, Hi: 0x1be7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be8, Hi: 0x1be9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bea, Hi: 0x1bec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bed, Hi: 0x1bed, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bee, Hi: 0x1bee, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bef, Hi: 0x1bf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bf2, Hi: 0x1bf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c24, Hi: 0x1c2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c2c, Hi: 0x1c33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c34, Hi: 0x1c35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c36, Hi: 0x1c37, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd0, Hi: 0x1cd2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd4, Hi: 0x1ce0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce1, Hi: 0x1ce1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce2, Hi: 0x1ce8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ced, Hi: 0x1ced, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf2, Hi: 0x1cf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf4, Hi: 0x1cf4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf8, Hi: 0x1cf9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dc0, Hi: 0x1df5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dfb, Hi: 0x1dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x200c, Hi: 0x200c, Stride: 0x1},
+		unicode.Range16{Lo: 0x20d0, Hi: 0x20dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x20dd, Hi: 0x20e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e1, Hi: 0x20e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e2, Hi: 0x20e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e5, Hi: 0x20f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cef, Hi: 0x2cf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d7f, Hi: 0x2d7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2de0, Hi: 0x2dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x302a, Hi: 0x302d, Stride: 0x1},
+		unicode.Range16{Lo: 0x302e, Hi: 0x302f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3099, Hi: 0x309a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66f, Hi: 0xa66f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa670, Hi: 0xa672, Stride: 0x1},
+		unicode.Range16{Lo: 0xa674, Hi: 0xa67d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69e, Hi: 0xa69f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6f0, Hi: 0xa6f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa802, Hi: 0xa802, Stride: 0x1},
+		unicode.Range16{Lo: 0xa806, Hi: 0xa806, Stride: 0x1},
+		unicode.Range16{Lo: 0xa80b, Hi: 0xa80b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa823, Hi: 0xa824, Stride: 0x1},
+		unicode.Range16{Lo: 0xa825, Hi: 0xa826, Stride: 0x1},
+		unicode.Range16{Lo: 0xa827, Hi: 0xa827, Stride: 0x1},
+		unicode.Range16{Lo: 0xa880, Hi: 0xa881, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8b4, Hi: 0xa8c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8c4, Hi: 0xa8c5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8e0, Hi: 0xa8f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa926, Hi: 0xa92d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa947, Hi: 0xa951, Stride: 0x1},
+		unicode.Range16{Lo: 0xa952, Hi: 0xa953, Stride: 0x1},
+		unicode.Range16{Lo: 0xa980, Hi: 0xa982, Stride: 0x1},
+		unicode.Range16{Lo: 0xa983, Hi: 0xa983, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b3, Hi: 0xa9b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b4, Hi: 0xa9b5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b6, Hi: 0xa9b9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9ba, Hi: 0xa9bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bc, Hi: 0xa9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bd, Hi: 0xa9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e5, Hi: 0xa9e5, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa29, Hi: 0xaa2e, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa2f, Hi: 0xaa30, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa31, Hi: 0xaa32, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa33, Hi: 0xaa34, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa35, Hi: 0xaa36, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa43, Hi: 0xaa43, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4c, Hi: 0xaa4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4d, Hi: 0xaa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7b, Hi: 0xaa7b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7c, Hi: 0xaa7c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7d, Hi: 0xaa7d, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab0, Hi: 0xaab0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab2, Hi: 0xaab4, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab7, Hi: 0xaab8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaabe, Hi: 0xaabf, Stride: 0x1},
+		unicode.Range16{Lo: 0xaac1, Hi: 0xaac1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaeb, Hi: 0xaaeb, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaec, Hi: 0xaaed, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaee, Hi: 0xaaef, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf5, Hi: 0xaaf5, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf6, Hi: 0xaaf6, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe3, Hi: 0xabe4, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe5, Hi: 0xabe5, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe6, Hi: 0xabe7, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe8, Hi: 0xabe8, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe9, Hi: 0xabea, Stride: 0x1},
+		unicode.Range16{Lo: 0xabec, Hi: 0xabec, Stride: 0x1},
+		unicode.Range16{Lo: 0xabed, Hi: 0xabed, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1e, Hi: 0xfb1e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe00, Hi: 0xfe0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe20, Hi: 0xfe2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff9e, Hi: 0xff9f, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x101fd, Hi: 0x101fd, Stride: 0x1},
+		unicode.Range32{Lo: 0x102e0, Hi: 0x102e0, Stride: 0x1},
+		unicode.Range32{Lo: 0x10376, Hi: 0x1037a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a01, Hi: 0x10a03, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a05, Hi: 0x10a06, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a0c, Hi: 0x10a0f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a38, Hi: 0x10a3a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a3f, Hi: 0x10a3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ae5, Hi: 0x10ae6, Stride: 0x1},
+		unicode.Range32{Lo: 0x11000, Hi: 0x11000, Stride: 0x1},
+		unicode.Range32{Lo: 0x11001, Hi: 0x11001, Stride: 0x1},
+		unicode.Range32{Lo: 0x11002, Hi: 0x11002, Stride: 0x1},
+		unicode.Range32{Lo: 0x11038, Hi: 0x11046, Stride: 0x1},
+		unicode.Range32{Lo: 0x1107f, Hi: 0x11081, Stride: 0x1},
+		unicode.Range32{Lo: 0x11082, Hi: 0x11082, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b0, Hi: 0x110b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b3, Hi: 0x110b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b7, Hi: 0x110b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b9, Hi: 0x110ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x11100, Hi: 0x11102, Stride: 0x1},
+		unicode.Range32{Lo: 0x11127, Hi: 0x1112b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112c, Hi: 0x1112c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112d, Hi: 0x11134, Stride: 0x1},
+		unicode.Range32{Lo: 0x11173, Hi: 0x11173, Stride: 0x1},
+		unicode.Range32{Lo: 0x11180, Hi: 0x11181, Stride: 0x1},
+		unicode.Range32{Lo: 0x11182, Hi: 0x11182, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b3, Hi: 0x111b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b6, Hi: 0x111be, Stride: 0x1},
+		unicode.Range32{Lo: 0x111bf, Hi: 0x111c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x111ca, Hi: 0x111cc, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122c, Hi: 0x1122e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122f, Hi: 0x11231, Stride: 0x1},
+		unicode.Range32{Lo: 0x11232, Hi: 0x11233, Stride: 0x1},
+		unicode.Range32{Lo: 0x11234, Hi: 0x11234, Stride: 0x1},
+		unicode.Range32{Lo: 0x11235, Hi: 0x11235, Stride: 0x1},
+		unicode.Range32{Lo: 0x11236, Hi: 0x11237, Stride: 0x1},
+		unicode.Range32{Lo: 0x1123e, Hi: 0x1123e, Stride: 0x1},
+		unicode.Range32{Lo: 0x112df, Hi: 0x112df, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e0, Hi: 0x112e2, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e3, Hi: 0x112ea, Stride: 0x1},
+		unicode.Range32{Lo: 0x11300, Hi: 0x11301, Stride: 0x1},
+		unicode.Range32{Lo: 0x11302, Hi: 0x11303, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133c, Hi: 0x1133c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133e, Hi: 0x1133f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11340, Hi: 0x11340, Stride: 0x1},
+		unicode.Range32{Lo: 0x11341, Hi: 0x11344, Stride: 0x1},
+		unicode.Range32{Lo: 0x11347, Hi: 0x11348, Stride: 0x1},
+		unicode.Range32{Lo: 0x1134b, Hi: 0x1134d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11357, Hi: 0x11357, Stride: 0x1},
+		unicode.Range32{Lo: 0x11362, Hi: 0x11363, Stride: 0x1},
+		unicode.Range32{Lo: 0x11366, Hi: 0x1136c, Stride: 0x1},
+		unicode.Range32{Lo: 0x11370, Hi: 0x11374, Stride: 0x1},
+		unicode.Range32{Lo: 0x11435, Hi: 0x11437, Stride: 0x1},
+		unicode.Range32{Lo: 0x11438, Hi: 0x1143f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11440, Hi: 0x11441, Stride: 0x1},
+		unicode.Range32{Lo: 0x11442, Hi: 0x11444, Stride: 0x1},
+		unicode.Range32{Lo: 0x11445, Hi: 0x11445, Stride: 0x1},
+		unicode.Range32{Lo: 0x11446, Hi: 0x11446, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b0, Hi: 0x114b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b3, Hi: 0x114b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b9, Hi: 0x114b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x114ba, Hi: 0x114ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bb, Hi: 0x114be, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bf, Hi: 0x114c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c1, Hi: 0x114c1, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c2, Hi: 0x114c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x115af, Hi: 0x115b1, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b2, Hi: 0x115b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b8, Hi: 0x115bb, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bc, Hi: 0x115bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x115be, Hi: 0x115be, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bf, Hi: 0x115c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x115dc, Hi: 0x115dd, Stride: 0x1},
+		unicode.Range32{Lo: 0x11630, Hi: 0x11632, Stride: 0x1},
+		unicode.Range32{Lo: 0x11633, Hi: 0x1163a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163b, Hi: 0x1163c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163d, Hi: 0x1163d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163e, Hi: 0x1163e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163f, Hi: 0x11640, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ab, Hi: 0x116ab, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ac, Hi: 0x116ac, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ad, Hi: 0x116ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ae, Hi: 0x116af, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b0, Hi: 0x116b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b6, Hi: 0x116b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b7, Hi: 0x116b7, Stride: 0x1},
+		unicode.Range32{Lo: 0x1171d, Hi: 0x1171f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11720, Hi: 0x11721, Stride: 0x1},
+		unicode.Range32{Lo: 0x11722, Hi: 0x11725, Stride: 0x1},
+		unicode.Range32{Lo: 0x11726, Hi: 0x11726, Stride: 0x1},
+		unicode.Range32{Lo: 0x11727, Hi: 0x1172b, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c2f, Hi: 0x11c2f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c30, Hi: 0x11c36, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c38, Hi: 0x11c3d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3e, Hi: 0x11c3e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3f, Hi: 0x11c3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c92, Hi: 0x11ca7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11ca9, Hi: 0x11ca9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11caa, Hi: 0x11cb0, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb1, Hi: 0x11cb1, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb2, Hi: 0x11cb3, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb4, Hi: 0x11cb4, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb5, Hi: 0x11cb6, Stride: 0x1},
+		unicode.Range32{Lo: 0x16af0, Hi: 0x16af4, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b30, Hi: 0x16b36, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f51, Hi: 0x16f7e, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f8f, Hi: 0x16f92, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc9d, Hi: 0x1bc9e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d165, Hi: 0x1d166, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d167, Hi: 0x1d169, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d16d, Hi: 0x1d172, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d17b, Hi: 0x1d182, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d185, Hi: 0x1d18b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d1aa, Hi: 0x1d1ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d242, Hi: 0x1d244, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da00, Hi: 0x1da36, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da3b, Hi: 0x1da6c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da75, Hi: 0x1da75, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da84, Hi: 0x1da84, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da9b, Hi: 0x1da9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1daa1, Hi: 0x1daaf, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e000, Hi: 0x1e006, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e008, Hi: 0x1e018, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e01b, Hi: 0x1e021, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e023, Hi: 0x1e024, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e026, Hi: 0x1e02a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e8d0, Hi: 0x1e8d6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e944, Hi: 0x1e94a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0020, Hi: 0xe007f, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0100, Hi: 0xe01ef, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordExtendNumLet = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x5f, Hi: 0x5f, Stride: 0x1},
+		unicode.Range16{Lo: 0x202f, Hi: 0x202f, Stride: 0x1},
+		unicode.Range16{Lo: 0x203f, Hi: 0x2040, Stride: 0x1},
+		unicode.Range16{Lo: 0x2054, Hi: 0x2054, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe33, Hi: 0xfe34, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe4d, Hi: 0xfe4f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff3f, Hi: 0xff3f, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordFormat = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xad, Hi: 0xad, Stride: 0x1},
+		unicode.Range16{Lo: 0x600, Hi: 0x605, Stride: 0x1},
+		unicode.Range16{Lo: 0x61c, Hi: 0x61c, Stride: 0x1},
+		unicode.Range16{Lo: 0x6dd, Hi: 0x6dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x70f, Hi: 0x70f, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e2, Hi: 0x8e2, Stride: 0x1},
+		unicode.Range16{Lo: 0x180e, Hi: 0x180e, Stride: 0x1},
+		unicode.Range16{Lo: 0x200e, Hi: 0x200f, Stride: 0x1},
+		unicode.Range16{Lo: 0x202a, Hi: 0x202e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2060, Hi: 0x2064, Stride: 0x1},
+		unicode.Range16{Lo: 0x2066, Hi: 0x206f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfeff, Hi: 0xfeff, Stride: 0x1},
+		unicode.Range16{Lo: 0xfff9, Hi: 0xfffb, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x110bd, Hi: 0x110bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bca0, Hi: 0x1bca3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d173, Hi: 0x1d17a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0001, Hi: 0xe0001, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordGlue_After_Zwj = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2764, Hi: 0x2764, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f48b, Hi: 0x1f48b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f5e8, Hi: 0x1f5e8, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordHebrew_Letter = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x5d0, Hi: 0x5ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x5f0, Hi: 0x5f2, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1d, Hi: 0xfb1d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1f, Hi: 0xfb28, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb2a, Hi: 0xfb36, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb38, Hi: 0xfb3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb3e, Hi: 0xfb3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb40, Hi: 0xfb41, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb43, Hi: 0xfb44, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb46, Hi: 0xfb4f, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordKatakana = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x3031, Hi: 0x3035, Stride: 0x1},
+		unicode.Range16{Lo: 0x309b, Hi: 0x309c, Stride: 0x1},
+		unicode.Range16{Lo: 0x30a0, Hi: 0x30a0, Stride: 0x1},
+		unicode.Range16{Lo: 0x30a1, Hi: 0x30fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x30fc, Hi: 0x30fe, Stride: 0x1},
+		unicode.Range16{Lo: 0x30ff, Hi: 0x30ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x31f0, Hi: 0x31ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x32d0, Hi: 0x32fe, Stride: 0x1},
+		unicode.Range16{Lo: 0x3300, Hi: 0x3357, Stride: 0x1},
+		unicode.Range16{Lo: 0xff66, Hi: 0xff6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff70, Hi: 0xff70, Stride: 0x1},
+		unicode.Range16{Lo: 0xff71, Hi: 0xff9d, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1b000, Hi: 0x1b000, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordLF = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xa, Hi: 0xa, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordMidLetter = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x3a, Hi: 0x3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xb7, Hi: 0xb7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d7, Hi: 0x2d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x387, Hi: 0x387, Stride: 0x1},
+		unicode.Range16{Lo: 0x5f4, Hi: 0x5f4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2027, Hi: 0x2027, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe13, Hi: 0xfe13, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe55, Hi: 0xfe55, Stride: 0x1},
+		unicode.Range16{Lo: 0xff1a, Hi: 0xff1a, Stride: 0x1},
+	},
+	LatinOffset: 2,
+}
+
+var _WordMidNum = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2c, Hi: 0x2c, Stride: 0x1},
+		unicode.Range16{Lo: 0x3b, Hi: 0x3b, Stride: 0x1},
+		unicode.Range16{Lo: 0x37e, Hi: 0x37e, Stride: 0x1},
+		unicode.Range16{Lo: 0x589, Hi: 0x589, Stride: 0x1},
+		unicode.Range16{Lo: 0x60c, Hi: 0x60d, Stride: 0x1},
+		unicode.Range16{Lo: 0x66c, Hi: 0x66c, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f8, Hi: 0x7f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2044, Hi: 0x2044, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe10, Hi: 0xfe10, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe14, Hi: 0xfe14, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe50, Hi: 0xfe50, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe54, Hi: 0xfe54, Stride: 0x1},
+		unicode.Range16{Lo: 0xff0c, Hi: 0xff0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xff1b, Hi: 0xff1b, Stride: 0x1},
+	},
+	LatinOffset: 2,
+}
+
+var _WordMidNumLet = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2e, Hi: 0x2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2018, Hi: 0x2018, Stride: 0x1},
+		unicode.Range16{Lo: 0x2019, Hi: 0x2019, Stride: 0x1},
+		unicode.Range16{Lo: 0x2024, Hi: 0x2024, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe52, Hi: 0xfe52, Stride: 0x1},
+		unicode.Range16{Lo: 0xff07, Hi: 0xff07, Stride: 0x1},
+		unicode.Range16{Lo: 0xff0e, Hi: 0xff0e, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordNewline = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xb, Hi: 0xc, Stride: 0x1},
+		unicode.Range16{Lo: 0x85, Hi: 0x85, Stride: 0x1},
+		unicode.Range16{Lo: 0x2028, Hi: 0x2028, Stride: 0x1},
+		unicode.Range16{Lo: 0x2029, Hi: 0x2029, Stride: 0x1},
+	},
+	LatinOffset: 2,
+}
+
+var _WordNumeric = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x30, Hi: 0x39, Stride: 0x1},
+		unicode.Range16{Lo: 0x660, Hi: 0x669, Stride: 0x1},
+		unicode.Range16{Lo: 0x66b, Hi: 0x66b, Stride: 0x1},
+		unicode.Range16{Lo: 0x6f0, Hi: 0x6f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x7c0, Hi: 0x7c9, Stride: 0x1},
+		unicode.Range16{Lo: 0x966, Hi: 0x96f, Stride: 0x1},
+		unicode.Range16{Lo: 0x9e6, Hi: 0x9ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66, Hi: 0xa6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xae6, Hi: 0xaef, Stride: 0x1},
+		unicode.Range16{Lo: 0xb66, Hi: 0xb6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe6, Hi: 0xbef, Stride: 0x1},
+		unicode.Range16{Lo: 0xc66, Hi: 0xc6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xce6, Hi: 0xcef, Stride: 0x1},
+		unicode.Range16{Lo: 0xd66, Hi: 0xd6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xde6, Hi: 0xdef, Stride: 0x1},
+		unicode.Range16{Lo: 0xe50, Hi: 0xe59, Stride: 0x1},
+		unicode.Range16{Lo: 0xed0, Hi: 0xed9, Stride: 0x1},
+		unicode.Range16{Lo: 0xf20, Hi: 0xf29, Stride: 0x1},
+		unicode.Range16{Lo: 0x1040, Hi: 0x1049, Stride: 0x1},
+		unicode.Range16{Lo: 0x1090, Hi: 0x1099, Stride: 0x1},
+		unicode.Range16{Lo: 0x17e0, Hi: 0x17e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1810, Hi: 0x1819, Stride: 0x1},
+		unicode.Range16{Lo: 0x1946, Hi: 0x194f, Stride: 0x1},
+		unicode.Range16{Lo: 0x19d0, Hi: 0x19d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a80, Hi: 0x1a89, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a90, Hi: 0x1a99, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b50, Hi: 0x1b59, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bb0, Hi: 0x1bb9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c40, Hi: 0x1c49, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c50, Hi: 0x1c59, Stride: 0x1},
+		unicode.Range16{Lo: 0xa620, Hi: 0xa629, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8d0, Hi: 0xa8d9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa900, Hi: 0xa909, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9d0, Hi: 0xa9d9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9f0, Hi: 0xa9f9, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa50, Hi: 0xaa59, Stride: 0x1},
+		unicode.Range16{Lo: 0xabf0, Hi: 0xabf9, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x104a0, Hi: 0x104a9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11066, Hi: 0x1106f, Stride: 0x1},
+		unicode.Range32{Lo: 0x110f0, Hi: 0x110f9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11136, Hi: 0x1113f, Stride: 0x1},
+		unicode.Range32{Lo: 0x111d0, Hi: 0x111d9, Stride: 0x1},
+		unicode.Range32{Lo: 0x112f0, Hi: 0x112f9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11450, Hi: 0x11459, Stride: 0x1},
+		unicode.Range32{Lo: 0x114d0, Hi: 0x114d9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11650, Hi: 0x11659, Stride: 0x1},
+		unicode.Range32{Lo: 0x116c0, Hi: 0x116c9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11730, Hi: 0x11739, Stride: 0x1},
+		unicode.Range32{Lo: 0x118e0, Hi: 0x118e9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c50, Hi: 0x11c59, Stride: 0x1},
+		unicode.Range32{Lo: 0x16a60, Hi: 0x16a69, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b50, Hi: 0x16b59, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7ce, Hi: 0x1d7ff, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e950, Hi: 0x1e959, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordRegional_Indicator = &unicode.RangeTable{
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f1e6, Hi: 0x1f1ff, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _WordSingle_Quote = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x27, Hi: 0x27, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _WordZWJ = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x200d, Hi: 0x200d, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+type _WordRuneRange unicode.RangeTable
+
+func _WordRuneType(r rune) *_WordRuneRange {
+	switch {
+	case unicode.Is(_WordALetter, r):
+		return (*_WordRuneRange)(_WordALetter)
+	case unicode.Is(_WordCR, r):
+		return (*_WordRuneRange)(_WordCR)
+	case unicode.Is(_WordDouble_Quote, r):
+		return (*_WordRuneRange)(_WordDouble_Quote)
+	case unicode.Is(_WordE_Base, r):
+		return (*_WordRuneRange)(_WordE_Base)
+	case unicode.Is(_WordE_Base_GAZ, r):
+		return (*_WordRuneRange)(_WordE_Base_GAZ)
+	case unicode.Is(_WordE_Modifier, r):
+		return (*_WordRuneRange)(_WordE_Modifier)
+	case unicode.Is(_WordExtend, r):
+		return (*_WordRuneRange)(_WordExtend)
+	case unicode.Is(_WordExtendNumLet, r):
+		return (*_WordRuneRange)(_WordExtendNumLet)
+	case unicode.Is(_WordFormat, r):
+		return (*_WordRuneRange)(_WordFormat)
+	case unicode.Is(_WordGlue_After_Zwj, r):
+		return (*_WordRuneRange)(_WordGlue_After_Zwj)
+	case unicode.Is(_WordHebrew_Letter, r):
+		return (*_WordRuneRange)(_WordHebrew_Letter)
+	case unicode.Is(_WordKatakana, r):
+		return (*_WordRuneRange)(_WordKatakana)
+	case unicode.Is(_WordLF, r):
+		return (*_WordRuneRange)(_WordLF)
+	case unicode.Is(_WordMidLetter, r):
+		return (*_WordRuneRange)(_WordMidLetter)
+	case unicode.Is(_WordMidNum, r):
+		return (*_WordRuneRange)(_WordMidNum)
+	case unicode.Is(_WordMidNumLet, r):
+		return (*_WordRuneRange)(_WordMidNumLet)
+	case unicode.Is(_WordNewline, r):
+		return (*_WordRuneRange)(_WordNewline)
+	case unicode.Is(_WordNumeric, r):
+		return (*_WordRuneRange)(_WordNumeric)
+	case unicode.Is(_WordRegional_Indicator, r):
+		return (*_WordRuneRange)(_WordRegional_Indicator)
+	case unicode.Is(_WordSingle_Quote, r):
+		return (*_WordRuneRange)(_WordSingle_Quote)
+	case unicode.Is(_WordZWJ, r):
+		return (*_WordRuneRange)(_WordZWJ)
+	default:
+		return nil
+	}
+}
+func (rng *_WordRuneRange) String() string {
+	switch (*unicode.RangeTable)(rng) {
+	case _WordALetter:
+		return "ALetter"
+	case _WordCR:
+		return "CR"
+	case _WordDouble_Quote:
+		return "Double_Quote"
+	case _WordE_Base:
+		return "E_Base"
+	case _WordE_Base_GAZ:
+		return "E_Base_GAZ"
+	case _WordE_Modifier:
+		return "E_Modifier"
+	case _WordExtend:
+		return "Extend"
+	case _WordExtendNumLet:
+		return "ExtendNumLet"
+	case _WordFormat:
+		return "Format"
+	case _WordGlue_After_Zwj:
+		return "Glue_After_Zwj"
+	case _WordHebrew_Letter:
+		return "Hebrew_Letter"
+	case _WordKatakana:
+		return "Katakana"
+	case _WordLF:
+		return "LF"
+	case _WordMidLetter:
+		return "MidLetter"
+	case _WordMidNum:
+		return "MidNum"
+	case _WordMidNumLet:
+		return "MidNumLet"
+	case _WordNewline:
+		return "Newline"
+	case _WordNumeric:
+		return "Numeric"
+	case _WordRegional_Indicator:
+		return "Regional_Indicator"
+	case _WordSingle_Quote:
+		return "Single_Quote"
+	case _WordZWJ:
+		return "ZWJ"
+	default:
+		return "Other"
+	}
+}
+
+var _SentenceATerm = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2e, Hi: 0x2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2024, Hi: 0x2024, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe52, Hi: 0xfe52, Stride: 0x1},
+		unicode.Range16{Lo: 0xff0e, Hi: 0xff0e, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceCR = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xd, Hi: 0xd, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceClose = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x22, Hi: 0x22, Stride: 0x1},
+		unicode.Range16{Lo: 0x27, Hi: 0x27, Stride: 0x1},
+		unicode.Range16{Lo: 0x28, Hi: 0x28, Stride: 0x1},
+		unicode.Range16{Lo: 0x29, Hi: 0x29, Stride: 0x1},
+		unicode.Range16{Lo: 0x5b, Hi: 0x5b, Stride: 0x1},
+		unicode.Range16{Lo: 0x5d, Hi: 0x5d, Stride: 0x1},
+		unicode.Range16{Lo: 0x7b, Hi: 0x7b, Stride: 0x1},
+		unicode.Range16{Lo: 0x7d, Hi: 0x7d, Stride: 0x1},
+		unicode.Range16{Lo: 0xab, Hi: 0xab, Stride: 0x1},
+		unicode.Range16{Lo: 0xbb, Hi: 0xbb, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3a, Hi: 0xf3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3b, Hi: 0xf3b, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3c, Hi: 0xf3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3d, Hi: 0xf3d, Stride: 0x1},
+		unicode.Range16{Lo: 0x169b, Hi: 0x169b, Stride: 0x1},
+		unicode.Range16{Lo: 0x169c, Hi: 0x169c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2018, Hi: 0x2018, Stride: 0x1},
+		unicode.Range16{Lo: 0x2019, Hi: 0x2019, Stride: 0x1},
+		unicode.Range16{Lo: 0x201a, Hi: 0x201a, Stride: 0x1},
+		unicode.Range16{Lo: 0x201b, Hi: 0x201c, Stride: 0x1},
+		unicode.Range16{Lo: 0x201d, Hi: 0x201d, Stride: 0x1},
+		unicode.Range16{Lo: 0x201e, Hi: 0x201e, Stride: 0x1},
+		unicode.Range16{Lo: 0x201f, Hi: 0x201f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2039, Hi: 0x2039, Stride: 0x1},
+		unicode.Range16{Lo: 0x203a, Hi: 0x203a, Stride: 0x1},
+		unicode.Range16{Lo: 0x2045, Hi: 0x2045, Stride: 0x1},
+		unicode.Range16{Lo: 0x2046, Hi: 0x2046, Stride: 0x1},
+		unicode.Range16{Lo: 0x207d, Hi: 0x207d, Stride: 0x1},
+		unicode.Range16{Lo: 0x207e, Hi: 0x207e, Stride: 0x1},
+		unicode.Range16{Lo: 0x208d, Hi: 0x208d, Stride: 0x1},
+		unicode.Range16{Lo: 0x208e, Hi: 0x208e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2308, Hi: 0x2308, Stride: 0x1},
+		unicode.Range16{Lo: 0x2309, Hi: 0x2309, Stride: 0x1},
+		unicode.Range16{Lo: 0x230a, Hi: 0x230a, Stride: 0x1},
+		unicode.Range16{Lo: 0x230b, Hi: 0x230b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2329, Hi: 0x2329, Stride: 0x1},
+		unicode.Range16{Lo: 0x232a, Hi: 0x232a, Stride: 0x1},
+		unicode.Range16{Lo: 0x275b, Hi: 0x2760, Stride: 0x1},
+		unicode.Range16{Lo: 0x2768, Hi: 0x2768, Stride: 0x1},
+		unicode.Range16{Lo: 0x2769, Hi: 0x2769, Stride: 0x1},
+		unicode.Range16{Lo: 0x276a, Hi: 0x276a, Stride: 0x1},
+		unicode.Range16{Lo: 0x276b, Hi: 0x276b, Stride: 0x1},
+		unicode.Range16{Lo: 0x276c, Hi: 0x276c, Stride: 0x1},
+		unicode.Range16{Lo: 0x276d, Hi: 0x276d, Stride: 0x1},
+		unicode.Range16{Lo: 0x276e, Hi: 0x276e, Stride: 0x1},
+		unicode.Range16{Lo: 0x276f, Hi: 0x276f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2770, Hi: 0x2770, Stride: 0x1},
+		unicode.Range16{Lo: 0x2771, Hi: 0x2771, Stride: 0x1},
+		unicode.Range16{Lo: 0x2772, Hi: 0x2772, Stride: 0x1},
+		unicode.Range16{Lo: 0x2773, Hi: 0x2773, Stride: 0x1},
+		unicode.Range16{Lo: 0x2774, Hi: 0x2774, Stride: 0x1},
+		unicode.Range16{Lo: 0x2775, Hi: 0x2775, Stride: 0x1},
+		unicode.Range16{Lo: 0x27c5, Hi: 0x27c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x27c6, Hi: 0x27c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x27e6, Hi: 0x27e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x27e7, Hi: 0x27e7, Stride: 0x1},
+		unicode.Range16{Lo: 0x27e8, Hi: 0x27e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x27e9, Hi: 0x27e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x27ea, Hi: 0x27ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x27eb, Hi: 0x27eb, Stride: 0x1},
+		unicode.Range16{Lo: 0x27ec, Hi: 0x27ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x27ed, Hi: 0x27ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x27ee, Hi: 0x27ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x27ef, Hi: 0x27ef, Stride: 0x1},
+		unicode.Range16{Lo: 0x2983, Hi: 0x2983, Stride: 0x1},
+		unicode.Range16{Lo: 0x2984, Hi: 0x2984, Stride: 0x1},
+		unicode.Range16{Lo: 0x2985, Hi: 0x2985, Stride: 0x1},
+		unicode.Range16{Lo: 0x2986, Hi: 0x2986, Stride: 0x1},
+		unicode.Range16{Lo: 0x2987, Hi: 0x2987, Stride: 0x1},
+		unicode.Range16{Lo: 0x2988, Hi: 0x2988, Stride: 0x1},
+		unicode.Range16{Lo: 0x2989, Hi: 0x2989, Stride: 0x1},
+		unicode.Range16{Lo: 0x298a, Hi: 0x298a, Stride: 0x1},
+		unicode.Range16{Lo: 0x298b, Hi: 0x298b, Stride: 0x1},
+		unicode.Range16{Lo: 0x298c, Hi: 0x298c, Stride: 0x1},
+		unicode.Range16{Lo: 0x298d, Hi: 0x298d, Stride: 0x1},
+		unicode.Range16{Lo: 0x298e, Hi: 0x298e, Stride: 0x1},
+		unicode.Range16{Lo: 0x298f, Hi: 0x298f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2990, Hi: 0x2990, Stride: 0x1},
+		unicode.Range16{Lo: 0x2991, Hi: 0x2991, Stride: 0x1},
+		unicode.Range16{Lo: 0x2992, Hi: 0x2992, Stride: 0x1},
+		unicode.Range16{Lo: 0x2993, Hi: 0x2993, Stride: 0x1},
+		unicode.Range16{Lo: 0x2994, Hi: 0x2994, Stride: 0x1},
+		unicode.Range16{Lo: 0x2995, Hi: 0x2995, Stride: 0x1},
+		unicode.Range16{Lo: 0x2996, Hi: 0x2996, Stride: 0x1},
+		unicode.Range16{Lo: 0x2997, Hi: 0x2997, Stride: 0x1},
+		unicode.Range16{Lo: 0x2998, Hi: 0x2998, Stride: 0x1},
+		unicode.Range16{Lo: 0x29d8, Hi: 0x29d8, Stride: 0x1},
+		unicode.Range16{Lo: 0x29d9, Hi: 0x29d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x29da, Hi: 0x29da, Stride: 0x1},
+		unicode.Range16{Lo: 0x29db, Hi: 0x29db, Stride: 0x1},
+		unicode.Range16{Lo: 0x29fc, Hi: 0x29fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x29fd, Hi: 0x29fd, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e00, Hi: 0x2e01, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e02, Hi: 0x2e02, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e03, Hi: 0x2e03, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e04, Hi: 0x2e04, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e05, Hi: 0x2e05, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e06, Hi: 0x2e08, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e09, Hi: 0x2e09, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0a, Hi: 0x2e0a, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0b, Hi: 0x2e0b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0c, Hi: 0x2e0c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0d, Hi: 0x2e0d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e1c, Hi: 0x2e1c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e1d, Hi: 0x2e1d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e20, Hi: 0x2e20, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e21, Hi: 0x2e21, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e22, Hi: 0x2e22, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e23, Hi: 0x2e23, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e24, Hi: 0x2e24, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e25, Hi: 0x2e25, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e26, Hi: 0x2e26, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e27, Hi: 0x2e27, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e28, Hi: 0x2e28, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e29, Hi: 0x2e29, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e42, Hi: 0x2e42, Stride: 0x1},
+		unicode.Range16{Lo: 0x3008, Hi: 0x3008, Stride: 0x1},
+		unicode.Range16{Lo: 0x3009, Hi: 0x3009, Stride: 0x1},
+		unicode.Range16{Lo: 0x300a, Hi: 0x300a, Stride: 0x1},
+		unicode.Range16{Lo: 0x300b, Hi: 0x300b, Stride: 0x1},
+		unicode.Range16{Lo: 0x300c, Hi: 0x300c, Stride: 0x1},
+		unicode.Range16{Lo: 0x300d, Hi: 0x300d, Stride: 0x1},
+		unicode.Range16{Lo: 0x300e, Hi: 0x300e, Stride: 0x1},
+		unicode.Range16{Lo: 0x300f, Hi: 0x300f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3010, Hi: 0x3010, Stride: 0x1},
+		unicode.Range16{Lo: 0x3011, Hi: 0x3011, Stride: 0x1},
+		unicode.Range16{Lo: 0x3014, Hi: 0x3014, Stride: 0x1},
+		unicode.Range16{Lo: 0x3015, Hi: 0x3015, Stride: 0x1},
+		unicode.Range16{Lo: 0x3016, Hi: 0x3016, Stride: 0x1},
+		unicode.Range16{Lo: 0x3017, Hi: 0x3017, Stride: 0x1},
+		unicode.Range16{Lo: 0x3018, Hi: 0x3018, Stride: 0x1},
+		unicode.Range16{Lo: 0x3019, Hi: 0x3019, Stride: 0x1},
+		unicode.Range16{Lo: 0x301a, Hi: 0x301a, Stride: 0x1},
+		unicode.Range16{Lo: 0x301b, Hi: 0x301b, Stride: 0x1},
+		unicode.Range16{Lo: 0x301d, Hi: 0x301d, Stride: 0x1},
+		unicode.Range16{Lo: 0x301e, Hi: 0x301f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd3e, Hi: 0xfd3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd3f, Hi: 0xfd3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe17, Hi: 0xfe17, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe18, Hi: 0xfe18, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe35, Hi: 0xfe35, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe36, Hi: 0xfe36, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe37, Hi: 0xfe37, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe38, Hi: 0xfe38, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe39, Hi: 0xfe39, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3a, Hi: 0xfe3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3b, Hi: 0xfe3b, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3c, Hi: 0xfe3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3d, Hi: 0xfe3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3e, Hi: 0xfe3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe3f, Hi: 0xfe3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe40, Hi: 0xfe40, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe41, Hi: 0xfe41, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe42, Hi: 0xfe42, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe43, Hi: 0xfe43, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe44, Hi: 0xfe44, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe47, Hi: 0xfe47, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe48, Hi: 0xfe48, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe59, Hi: 0xfe59, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe5a, Hi: 0xfe5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe5b, Hi: 0xfe5b, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe5c, Hi: 0xfe5c, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe5d, Hi: 0xfe5d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe5e, Hi: 0xfe5e, Stride: 0x1},
+		unicode.Range16{Lo: 0xff08, Hi: 0xff08, Stride: 0x1},
+		unicode.Range16{Lo: 0xff09, Hi: 0xff09, Stride: 0x1},
+		unicode.Range16{Lo: 0xff3b, Hi: 0xff3b, Stride: 0x1},
+		unicode.Range16{Lo: 0xff3d, Hi: 0xff3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xff5b, Hi: 0xff5b, Stride: 0x1},
+		unicode.Range16{Lo: 0xff5d, Hi: 0xff5d, Stride: 0x1},
+		unicode.Range16{Lo: 0xff5f, Hi: 0xff5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff60, Hi: 0xff60, Stride: 0x1},
+		unicode.Range16{Lo: 0xff62, Hi: 0xff62, Stride: 0x1},
+		unicode.Range16{Lo: 0xff63, Hi: 0xff63, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x1f676, Hi: 0x1f678, Stride: 0x1},
+	},
+	LatinOffset: 10,
+}
+
+var _SentenceExtend = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x300, Hi: 0x36f, Stride: 0x1},
+		unicode.Range16{Lo: 0x483, Hi: 0x487, Stride: 0x1},
+		unicode.Range16{Lo: 0x488, Hi: 0x489, Stride: 0x1},
+		unicode.Range16{Lo: 0x591, Hi: 0x5bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x5bf, Hi: 0x5bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c1, Hi: 0x5c2, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c4, Hi: 0x5c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x5c7, Hi: 0x5c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x610, Hi: 0x61a, Stride: 0x1},
+		unicode.Range16{Lo: 0x64b, Hi: 0x65f, Stride: 0x1},
+		unicode.Range16{Lo: 0x670, Hi: 0x670, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d6, Hi: 0x6dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x6df, Hi: 0x6e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x6e7, Hi: 0x6e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ea, Hi: 0x6ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x711, Hi: 0x711, Stride: 0x1},
+		unicode.Range16{Lo: 0x730, Hi: 0x74a, Stride: 0x1},
+		unicode.Range16{Lo: 0x7a6, Hi: 0x7b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x7eb, Hi: 0x7f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x816, Hi: 0x819, Stride: 0x1},
+		unicode.Range16{Lo: 0x81b, Hi: 0x823, Stride: 0x1},
+		unicode.Range16{Lo: 0x825, Hi: 0x827, Stride: 0x1},
+		unicode.Range16{Lo: 0x829, Hi: 0x82d, Stride: 0x1},
+		unicode.Range16{Lo: 0x859, Hi: 0x85b, Stride: 0x1},
+		unicode.Range16{Lo: 0x8d4, Hi: 0x8e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e3, Hi: 0x902, Stride: 0x1},
+		unicode.Range16{Lo: 0x903, Hi: 0x903, Stride: 0x1},
+		unicode.Range16{Lo: 0x93a, Hi: 0x93a, Stride: 0x1},
+		unicode.Range16{Lo: 0x93b, Hi: 0x93b, Stride: 0x1},
+		unicode.Range16{Lo: 0x93c, Hi: 0x93c, Stride: 0x1},
+		unicode.Range16{Lo: 0x93e, Hi: 0x940, Stride: 0x1},
+		unicode.Range16{Lo: 0x941, Hi: 0x948, Stride: 0x1},
+		unicode.Range16{Lo: 0x949, Hi: 0x94c, Stride: 0x1},
+		unicode.Range16{Lo: 0x94d, Hi: 0x94d, Stride: 0x1},
+		unicode.Range16{Lo: 0x94e, Hi: 0x94f, Stride: 0x1},
+		unicode.Range16{Lo: 0x951, Hi: 0x957, Stride: 0x1},
+		unicode.Range16{Lo: 0x962, Hi: 0x963, Stride: 0x1},
+		unicode.Range16{Lo: 0x981, Hi: 0x981, Stride: 0x1},
+		unicode.Range16{Lo: 0x982, Hi: 0x983, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bc, Hi: 0x9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0x9be, Hi: 0x9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c1, Hi: 0x9c4, Stride: 0x1},
+		unicode.Range16{Lo: 0x9c7, Hi: 0x9c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cb, Hi: 0x9cc, Stride: 0x1},
+		unicode.Range16{Lo: 0x9cd, Hi: 0x9cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9d7, Hi: 0x9d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x9e2, Hi: 0x9e3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa01, Hi: 0xa02, Stride: 0x1},
+		unicode.Range16{Lo: 0xa03, Hi: 0xa03, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3c, Hi: 0xa3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa3e, Hi: 0xa40, Stride: 0x1},
+		unicode.Range16{Lo: 0xa41, Hi: 0xa42, Stride: 0x1},
+		unicode.Range16{Lo: 0xa47, Hi: 0xa48, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4b, Hi: 0xa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa51, Hi: 0xa51, Stride: 0x1},
+		unicode.Range16{Lo: 0xa70, Hi: 0xa71, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75, Hi: 0xa75, Stride: 0x1},
+		unicode.Range16{Lo: 0xa81, Hi: 0xa82, Stride: 0x1},
+		unicode.Range16{Lo: 0xa83, Hi: 0xa83, Stride: 0x1},
+		unicode.Range16{Lo: 0xabc, Hi: 0xabc, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe, Hi: 0xac0, Stride: 0x1},
+		unicode.Range16{Lo: 0xac1, Hi: 0xac5, Stride: 0x1},
+		unicode.Range16{Lo: 0xac7, Hi: 0xac8, Stride: 0x1},
+		unicode.Range16{Lo: 0xac9, Hi: 0xac9, Stride: 0x1},
+		unicode.Range16{Lo: 0xacb, Hi: 0xacc, Stride: 0x1},
+		unicode.Range16{Lo: 0xacd, Hi: 0xacd, Stride: 0x1},
+		unicode.Range16{Lo: 0xae2, Hi: 0xae3, Stride: 0x1},
+		unicode.Range16{Lo: 0xb01, Hi: 0xb01, Stride: 0x1},
+		unicode.Range16{Lo: 0xb02, Hi: 0xb03, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3c, Hi: 0xb3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3e, Hi: 0xb3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3f, Hi: 0xb3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xb40, Hi: 0xb40, Stride: 0x1},
+		unicode.Range16{Lo: 0xb41, Hi: 0xb44, Stride: 0x1},
+		unicode.Range16{Lo: 0xb47, Hi: 0xb48, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4b, Hi: 0xb4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb4d, Hi: 0xb4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb56, Hi: 0xb56, Stride: 0x1},
+		unicode.Range16{Lo: 0xb57, Hi: 0xb57, Stride: 0x1},
+		unicode.Range16{Lo: 0xb62, Hi: 0xb63, Stride: 0x1},
+		unicode.Range16{Lo: 0xb82, Hi: 0xb82, Stride: 0x1},
+		unicode.Range16{Lo: 0xbbe, Hi: 0xbbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc0, Hi: 0xbc0, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc1, Hi: 0xbc2, Stride: 0x1},
+		unicode.Range16{Lo: 0xbc6, Hi: 0xbc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xbca, Hi: 0xbcc, Stride: 0x1},
+		unicode.Range16{Lo: 0xbcd, Hi: 0xbcd, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd7, Hi: 0xbd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xc00, Hi: 0xc00, Stride: 0x1},
+		unicode.Range16{Lo: 0xc01, Hi: 0xc03, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3e, Hi: 0xc40, Stride: 0x1},
+		unicode.Range16{Lo: 0xc41, Hi: 0xc44, Stride: 0x1},
+		unicode.Range16{Lo: 0xc46, Hi: 0xc48, Stride: 0x1},
+		unicode.Range16{Lo: 0xc4a, Hi: 0xc4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xc55, Hi: 0xc56, Stride: 0x1},
+		unicode.Range16{Lo: 0xc62, Hi: 0xc63, Stride: 0x1},
+		unicode.Range16{Lo: 0xc81, Hi: 0xc81, Stride: 0x1},
+		unicode.Range16{Lo: 0xc82, Hi: 0xc83, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbc, Hi: 0xcbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbe, Hi: 0xcbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbf, Hi: 0xcbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc0, Hi: 0xcc4, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc6, Hi: 0xcc6, Stride: 0x1},
+		unicode.Range16{Lo: 0xcc7, Hi: 0xcc8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcca, Hi: 0xccb, Stride: 0x1},
+		unicode.Range16{Lo: 0xccc, Hi: 0xccd, Stride: 0x1},
+		unicode.Range16{Lo: 0xcd5, Hi: 0xcd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xce2, Hi: 0xce3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd01, Hi: 0xd01, Stride: 0x1},
+		unicode.Range16{Lo: 0xd02, Hi: 0xd03, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3e, Hi: 0xd40, Stride: 0x1},
+		unicode.Range16{Lo: 0xd41, Hi: 0xd44, Stride: 0x1},
+		unicode.Range16{Lo: 0xd46, Hi: 0xd48, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4a, Hi: 0xd4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4d, Hi: 0xd4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xd57, Hi: 0xd57, Stride: 0x1},
+		unicode.Range16{Lo: 0xd62, Hi: 0xd63, Stride: 0x1},
+		unicode.Range16{Lo: 0xd82, Hi: 0xd83, Stride: 0x1},
+		unicode.Range16{Lo: 0xdca, Hi: 0xdca, Stride: 0x1},
+		unicode.Range16{Lo: 0xdcf, Hi: 0xdd1, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd2, Hi: 0xdd4, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd6, Hi: 0xdd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xdd8, Hi: 0xddf, Stride: 0x1},
+		unicode.Range16{Lo: 0xdf2, Hi: 0xdf3, Stride: 0x1},
+		unicode.Range16{Lo: 0xe31, Hi: 0xe31, Stride: 0x1},
+		unicode.Range16{Lo: 0xe34, Hi: 0xe3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xe47, Hi: 0xe4e, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb1, Hi: 0xeb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb4, Hi: 0xeb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xebb, Hi: 0xebc, Stride: 0x1},
+		unicode.Range16{Lo: 0xec8, Hi: 0xecd, Stride: 0x1},
+		unicode.Range16{Lo: 0xf18, Hi: 0xf19, Stride: 0x1},
+		unicode.Range16{Lo: 0xf35, Hi: 0xf35, Stride: 0x1},
+		unicode.Range16{Lo: 0xf37, Hi: 0xf37, Stride: 0x1},
+		unicode.Range16{Lo: 0xf39, Hi: 0xf39, Stride: 0x1},
+		unicode.Range16{Lo: 0xf3e, Hi: 0xf3f, Stride: 0x1},
+		unicode.Range16{Lo: 0xf71, Hi: 0xf7e, Stride: 0x1},
+		unicode.Range16{Lo: 0xf7f, Hi: 0xf7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xf80, Hi: 0xf84, Stride: 0x1},
+		unicode.Range16{Lo: 0xf86, Hi: 0xf87, Stride: 0x1},
+		unicode.Range16{Lo: 0xf8d, Hi: 0xf97, Stride: 0x1},
+		unicode.Range16{Lo: 0xf99, Hi: 0xfbc, Stride: 0x1},
+		unicode.Range16{Lo: 0xfc6, Hi: 0xfc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x102b, Hi: 0x102c, Stride: 0x1},
+		unicode.Range16{Lo: 0x102d, Hi: 0x1030, Stride: 0x1},
+		unicode.Range16{Lo: 0x1031, Hi: 0x1031, Stride: 0x1},
+		unicode.Range16{Lo: 0x1032, Hi: 0x1037, Stride: 0x1},
+		unicode.Range16{Lo: 0x1038, Hi: 0x1038, Stride: 0x1},
+		unicode.Range16{Lo: 0x1039, Hi: 0x103a, Stride: 0x1},
+		unicode.Range16{Lo: 0x103b, Hi: 0x103c, Stride: 0x1},
+		unicode.Range16{Lo: 0x103d, Hi: 0x103e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1056, Hi: 0x1057, Stride: 0x1},
+		unicode.Range16{Lo: 0x1058, Hi: 0x1059, Stride: 0x1},
+		unicode.Range16{Lo: 0x105e, Hi: 0x1060, Stride: 0x1},
+		unicode.Range16{Lo: 0x1062, Hi: 0x1064, Stride: 0x1},
+		unicode.Range16{Lo: 0x1067, Hi: 0x106d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1071, Hi: 0x1074, Stride: 0x1},
+		unicode.Range16{Lo: 0x1082, Hi: 0x1082, Stride: 0x1},
+		unicode.Range16{Lo: 0x1083, Hi: 0x1084, Stride: 0x1},
+		unicode.Range16{Lo: 0x1085, Hi: 0x1086, Stride: 0x1},
+		unicode.Range16{Lo: 0x1087, Hi: 0x108c, Stride: 0x1},
+		unicode.Range16{Lo: 0x108d, Hi: 0x108d, Stride: 0x1},
+		unicode.Range16{Lo: 0x108f, Hi: 0x108f, Stride: 0x1},
+		unicode.Range16{Lo: 0x109a, Hi: 0x109c, Stride: 0x1},
+		unicode.Range16{Lo: 0x109d, Hi: 0x109d, Stride: 0x1},
+		unicode.Range16{Lo: 0x135d, Hi: 0x135f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1712, Hi: 0x1714, Stride: 0x1},
+		unicode.Range16{Lo: 0x1732, Hi: 0x1734, Stride: 0x1},
+		unicode.Range16{Lo: 0x1752, Hi: 0x1753, Stride: 0x1},
+		unicode.Range16{Lo: 0x1772, Hi: 0x1773, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b4, Hi: 0x17b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b6, Hi: 0x17b6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b7, Hi: 0x17bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x17be, Hi: 0x17c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c6, Hi: 0x17c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c7, Hi: 0x17c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c9, Hi: 0x17d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x17dd, Hi: 0x17dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x180b, Hi: 0x180d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1885, Hi: 0x1886, Stride: 0x1},
+		unicode.Range16{Lo: 0x18a9, Hi: 0x18a9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1920, Hi: 0x1922, Stride: 0x1},
+		unicode.Range16{Lo: 0x1923, Hi: 0x1926, Stride: 0x1},
+		unicode.Range16{Lo: 0x1927, Hi: 0x1928, Stride: 0x1},
+		unicode.Range16{Lo: 0x1929, Hi: 0x192b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1930, Hi: 0x1931, Stride: 0x1},
+		unicode.Range16{Lo: 0x1932, Hi: 0x1932, Stride: 0x1},
+		unicode.Range16{Lo: 0x1933, Hi: 0x1938, Stride: 0x1},
+		unicode.Range16{Lo: 0x1939, Hi: 0x193b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a17, Hi: 0x1a18, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a19, Hi: 0x1a1a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a1b, Hi: 0x1a1b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a55, Hi: 0x1a55, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a56, Hi: 0x1a56, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a57, Hi: 0x1a57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a58, Hi: 0x1a5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a60, Hi: 0x1a60, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a61, Hi: 0x1a61, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a62, Hi: 0x1a62, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a63, Hi: 0x1a64, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a65, Hi: 0x1a6c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a6d, Hi: 0x1a72, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a73, Hi: 0x1a7c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a7f, Hi: 0x1a7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ab0, Hi: 0x1abd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1abe, Hi: 0x1abe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b00, Hi: 0x1b03, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b04, Hi: 0x1b04, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b34, Hi: 0x1b34, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b35, Hi: 0x1b35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b36, Hi: 0x1b3a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3b, Hi: 0x1b3b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3c, Hi: 0x1b3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b3d, Hi: 0x1b41, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b42, Hi: 0x1b42, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b43, Hi: 0x1b44, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b6b, Hi: 0x1b73, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b80, Hi: 0x1b81, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b82, Hi: 0x1b82, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba1, Hi: 0x1ba1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba2, Hi: 0x1ba5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba6, Hi: 0x1ba7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ba8, Hi: 0x1ba9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1baa, Hi: 0x1baa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bab, Hi: 0x1bad, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be6, Hi: 0x1be6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be7, Hi: 0x1be7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1be8, Hi: 0x1be9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bea, Hi: 0x1bec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bed, Hi: 0x1bed, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bee, Hi: 0x1bee, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bef, Hi: 0x1bf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bf2, Hi: 0x1bf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c24, Hi: 0x1c2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c2c, Hi: 0x1c33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c34, Hi: 0x1c35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c36, Hi: 0x1c37, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd0, Hi: 0x1cd2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd4, Hi: 0x1ce0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce1, Hi: 0x1ce1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce2, Hi: 0x1ce8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ced, Hi: 0x1ced, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf2, Hi: 0x1cf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf4, Hi: 0x1cf4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf8, Hi: 0x1cf9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dc0, Hi: 0x1df5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dfb, Hi: 0x1dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x200c, Hi: 0x200d, Stride: 0x1},
+		unicode.Range16{Lo: 0x20d0, Hi: 0x20dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x20dd, Hi: 0x20e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e1, Hi: 0x20e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e2, Hi: 0x20e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e5, Hi: 0x20f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cef, Hi: 0x2cf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d7f, Hi: 0x2d7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2de0, Hi: 0x2dff, Stride: 0x1},
+		unicode.Range16{Lo: 0x302a, Hi: 0x302d, Stride: 0x1},
+		unicode.Range16{Lo: 0x302e, Hi: 0x302f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3099, Hi: 0x309a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66f, Hi: 0xa66f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa670, Hi: 0xa672, Stride: 0x1},
+		unicode.Range16{Lo: 0xa674, Hi: 0xa67d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69e, Hi: 0xa69f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6f0, Hi: 0xa6f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa802, Hi: 0xa802, Stride: 0x1},
+		unicode.Range16{Lo: 0xa806, Hi: 0xa806, Stride: 0x1},
+		unicode.Range16{Lo: 0xa80b, Hi: 0xa80b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa823, Hi: 0xa824, Stride: 0x1},
+		unicode.Range16{Lo: 0xa825, Hi: 0xa826, Stride: 0x1},
+		unicode.Range16{Lo: 0xa827, Hi: 0xa827, Stride: 0x1},
+		unicode.Range16{Lo: 0xa880, Hi: 0xa881, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8b4, Hi: 0xa8c3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8c4, Hi: 0xa8c5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8e0, Hi: 0xa8f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa926, Hi: 0xa92d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa947, Hi: 0xa951, Stride: 0x1},
+		unicode.Range16{Lo: 0xa952, Hi: 0xa953, Stride: 0x1},
+		unicode.Range16{Lo: 0xa980, Hi: 0xa982, Stride: 0x1},
+		unicode.Range16{Lo: 0xa983, Hi: 0xa983, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b3, Hi: 0xa9b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b4, Hi: 0xa9b5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9b6, Hi: 0xa9b9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9ba, Hi: 0xa9bb, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bc, Hi: 0xa9bc, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9bd, Hi: 0xa9c0, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e5, Hi: 0xa9e5, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa29, Hi: 0xaa2e, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa2f, Hi: 0xaa30, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa31, Hi: 0xaa32, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa33, Hi: 0xaa34, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa35, Hi: 0xaa36, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa43, Hi: 0xaa43, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4c, Hi: 0xaa4c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa4d, Hi: 0xaa4d, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7b, Hi: 0xaa7b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7c, Hi: 0xaa7c, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7d, Hi: 0xaa7d, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab0, Hi: 0xaab0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab2, Hi: 0xaab4, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab7, Hi: 0xaab8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaabe, Hi: 0xaabf, Stride: 0x1},
+		unicode.Range16{Lo: 0xaac1, Hi: 0xaac1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaeb, Hi: 0xaaeb, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaec, Hi: 0xaaed, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaee, Hi: 0xaaef, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf5, Hi: 0xaaf5, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf6, Hi: 0xaaf6, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe3, Hi: 0xabe4, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe5, Hi: 0xabe5, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe6, Hi: 0xabe7, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe8, Hi: 0xabe8, Stride: 0x1},
+		unicode.Range16{Lo: 0xabe9, Hi: 0xabea, Stride: 0x1},
+		unicode.Range16{Lo: 0xabec, Hi: 0xabec, Stride: 0x1},
+		unicode.Range16{Lo: 0xabed, Hi: 0xabed, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1e, Hi: 0xfb1e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe00, Hi: 0xfe0f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe20, Hi: 0xfe2f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff9e, Hi: 0xff9f, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x101fd, Hi: 0x101fd, Stride: 0x1},
+		unicode.Range32{Lo: 0x102e0, Hi: 0x102e0, Stride: 0x1},
+		unicode.Range32{Lo: 0x10376, Hi: 0x1037a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a01, Hi: 0x10a03, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a05, Hi: 0x10a06, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a0c, Hi: 0x10a0f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a38, Hi: 0x10a3a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a3f, Hi: 0x10a3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ae5, Hi: 0x10ae6, Stride: 0x1},
+		unicode.Range32{Lo: 0x11000, Hi: 0x11000, Stride: 0x1},
+		unicode.Range32{Lo: 0x11001, Hi: 0x11001, Stride: 0x1},
+		unicode.Range32{Lo: 0x11002, Hi: 0x11002, Stride: 0x1},
+		unicode.Range32{Lo: 0x11038, Hi: 0x11046, Stride: 0x1},
+		unicode.Range32{Lo: 0x1107f, Hi: 0x11081, Stride: 0x1},
+		unicode.Range32{Lo: 0x11082, Hi: 0x11082, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b0, Hi: 0x110b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b3, Hi: 0x110b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b7, Hi: 0x110b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x110b9, Hi: 0x110ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x11100, Hi: 0x11102, Stride: 0x1},
+		unicode.Range32{Lo: 0x11127, Hi: 0x1112b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112c, Hi: 0x1112c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1112d, Hi: 0x11134, Stride: 0x1},
+		unicode.Range32{Lo: 0x11173, Hi: 0x11173, Stride: 0x1},
+		unicode.Range32{Lo: 0x11180, Hi: 0x11181, Stride: 0x1},
+		unicode.Range32{Lo: 0x11182, Hi: 0x11182, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b3, Hi: 0x111b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x111b6, Hi: 0x111be, Stride: 0x1},
+		unicode.Range32{Lo: 0x111bf, Hi: 0x111c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x111ca, Hi: 0x111cc, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122c, Hi: 0x1122e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1122f, Hi: 0x11231, Stride: 0x1},
+		unicode.Range32{Lo: 0x11232, Hi: 0x11233, Stride: 0x1},
+		unicode.Range32{Lo: 0x11234, Hi: 0x11234, Stride: 0x1},
+		unicode.Range32{Lo: 0x11235, Hi: 0x11235, Stride: 0x1},
+		unicode.Range32{Lo: 0x11236, Hi: 0x11237, Stride: 0x1},
+		unicode.Range32{Lo: 0x1123e, Hi: 0x1123e, Stride: 0x1},
+		unicode.Range32{Lo: 0x112df, Hi: 0x112df, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e0, Hi: 0x112e2, Stride: 0x1},
+		unicode.Range32{Lo: 0x112e3, Hi: 0x112ea, Stride: 0x1},
+		unicode.Range32{Lo: 0x11300, Hi: 0x11301, Stride: 0x1},
+		unicode.Range32{Lo: 0x11302, Hi: 0x11303, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133c, Hi: 0x1133c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133e, Hi: 0x1133f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11340, Hi: 0x11340, Stride: 0x1},
+		unicode.Range32{Lo: 0x11341, Hi: 0x11344, Stride: 0x1},
+		unicode.Range32{Lo: 0x11347, Hi: 0x11348, Stride: 0x1},
+		unicode.Range32{Lo: 0x1134b, Hi: 0x1134d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11357, Hi: 0x11357, Stride: 0x1},
+		unicode.Range32{Lo: 0x11362, Hi: 0x11363, Stride: 0x1},
+		unicode.Range32{Lo: 0x11366, Hi: 0x1136c, Stride: 0x1},
+		unicode.Range32{Lo: 0x11370, Hi: 0x11374, Stride: 0x1},
+		unicode.Range32{Lo: 0x11435, Hi: 0x11437, Stride: 0x1},
+		unicode.Range32{Lo: 0x11438, Hi: 0x1143f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11440, Hi: 0x11441, Stride: 0x1},
+		unicode.Range32{Lo: 0x11442, Hi: 0x11444, Stride: 0x1},
+		unicode.Range32{Lo: 0x11445, Hi: 0x11445, Stride: 0x1},
+		unicode.Range32{Lo: 0x11446, Hi: 0x11446, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b0, Hi: 0x114b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b3, Hi: 0x114b8, Stride: 0x1},
+		unicode.Range32{Lo: 0x114b9, Hi: 0x114b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x114ba, Hi: 0x114ba, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bb, Hi: 0x114be, Stride: 0x1},
+		unicode.Range32{Lo: 0x114bf, Hi: 0x114c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c1, Hi: 0x114c1, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c2, Hi: 0x114c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x115af, Hi: 0x115b1, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b2, Hi: 0x115b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x115b8, Hi: 0x115bb, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bc, Hi: 0x115bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x115be, Hi: 0x115be, Stride: 0x1},
+		unicode.Range32{Lo: 0x115bf, Hi: 0x115c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x115dc, Hi: 0x115dd, Stride: 0x1},
+		unicode.Range32{Lo: 0x11630, Hi: 0x11632, Stride: 0x1},
+		unicode.Range32{Lo: 0x11633, Hi: 0x1163a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163b, Hi: 0x1163c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163d, Hi: 0x1163d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163e, Hi: 0x1163e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1163f, Hi: 0x11640, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ab, Hi: 0x116ab, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ac, Hi: 0x116ac, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ad, Hi: 0x116ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x116ae, Hi: 0x116af, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b0, Hi: 0x116b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b6, Hi: 0x116b6, Stride: 0x1},
+		unicode.Range32{Lo: 0x116b7, Hi: 0x116b7, Stride: 0x1},
+		unicode.Range32{Lo: 0x1171d, Hi: 0x1171f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11720, Hi: 0x11721, Stride: 0x1},
+		unicode.Range32{Lo: 0x11722, Hi: 0x11725, Stride: 0x1},
+		unicode.Range32{Lo: 0x11726, Hi: 0x11726, Stride: 0x1},
+		unicode.Range32{Lo: 0x11727, Hi: 0x1172b, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c2f, Hi: 0x11c2f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c30, Hi: 0x11c36, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c38, Hi: 0x11c3d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3e, Hi: 0x11c3e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c3f, Hi: 0x11c3f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c92, Hi: 0x11ca7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11ca9, Hi: 0x11ca9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11caa, Hi: 0x11cb0, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb1, Hi: 0x11cb1, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb2, Hi: 0x11cb3, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb4, Hi: 0x11cb4, Stride: 0x1},
+		unicode.Range32{Lo: 0x11cb5, Hi: 0x11cb6, Stride: 0x1},
+		unicode.Range32{Lo: 0x16af0, Hi: 0x16af4, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b30, Hi: 0x16b36, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f51, Hi: 0x16f7e, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f8f, Hi: 0x16f92, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc9d, Hi: 0x1bc9e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d165, Hi: 0x1d166, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d167, Hi: 0x1d169, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d16d, Hi: 0x1d172, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d17b, Hi: 0x1d182, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d185, Hi: 0x1d18b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d1aa, Hi: 0x1d1ad, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d242, Hi: 0x1d244, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da00, Hi: 0x1da36, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da3b, Hi: 0x1da6c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da75, Hi: 0x1da75, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da84, Hi: 0x1da84, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da9b, Hi: 0x1da9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1daa1, Hi: 0x1daaf, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e000, Hi: 0x1e006, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e008, Hi: 0x1e018, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e01b, Hi: 0x1e021, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e023, Hi: 0x1e024, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e026, Hi: 0x1e02a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e8d0, Hi: 0x1e8d6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e944, Hi: 0x1e94a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0020, Hi: 0xe007f, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0100, Hi: 0xe01ef, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _SentenceFormat = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xad, Hi: 0xad, Stride: 0x1},
+		unicode.Range16{Lo: 0x600, Hi: 0x605, Stride: 0x1},
+		unicode.Range16{Lo: 0x61c, Hi: 0x61c, Stride: 0x1},
+		unicode.Range16{Lo: 0x6dd, Hi: 0x6dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x70f, Hi: 0x70f, Stride: 0x1},
+		unicode.Range16{Lo: 0x8e2, Hi: 0x8e2, Stride: 0x1},
+		unicode.Range16{Lo: 0x180e, Hi: 0x180e, Stride: 0x1},
+		unicode.Range16{Lo: 0x200b, Hi: 0x200b, Stride: 0x1},
+		unicode.Range16{Lo: 0x200e, Hi: 0x200f, Stride: 0x1},
+		unicode.Range16{Lo: 0x202a, Hi: 0x202e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2060, Hi: 0x2064, Stride: 0x1},
+		unicode.Range16{Lo: 0x2066, Hi: 0x206f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfeff, Hi: 0xfeff, Stride: 0x1},
+		unicode.Range16{Lo: 0xfff9, Hi: 0xfffb, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x110bd, Hi: 0x110bd, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bca0, Hi: 0x1bca3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d173, Hi: 0x1d17a, Stride: 0x1},
+		unicode.Range32{Lo: 0xe0001, Hi: 0xe0001, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceLF = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0xa, Hi: 0xa, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceLower = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x61, Hi: 0x7a, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa, Hi: 0xaa, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5, Hi: 0xb5, Stride: 0x1},
+		unicode.Range16{Lo: 0xba, Hi: 0xba, Stride: 0x1},
+		unicode.Range16{Lo: 0xdf, Hi: 0xf6, Stride: 0x1},
+		unicode.Range16{Lo: 0xf8, Hi: 0xff, Stride: 0x1},
+		unicode.Range16{Lo: 0x101, Hi: 0x101, Stride: 0x1},
+		unicode.Range16{Lo: 0x103, Hi: 0x103, Stride: 0x1},
+		unicode.Range16{Lo: 0x105, Hi: 0x105, Stride: 0x1},
+		unicode.Range16{Lo: 0x107, Hi: 0x107, Stride: 0x1},
+		unicode.Range16{Lo: 0x109, Hi: 0x109, Stride: 0x1},
+		unicode.Range16{Lo: 0x10b, Hi: 0x10b, Stride: 0x1},
+		unicode.Range16{Lo: 0x10d, Hi: 0x10d, Stride: 0x1},
+		unicode.Range16{Lo: 0x10f, Hi: 0x10f, Stride: 0x1},
+		unicode.Range16{Lo: 0x111, Hi: 0x111, Stride: 0x1},
+		unicode.Range16{Lo: 0x113, Hi: 0x113, Stride: 0x1},
+		unicode.Range16{Lo: 0x115, Hi: 0x115, Stride: 0x1},
+		unicode.Range16{Lo: 0x117, Hi: 0x117, Stride: 0x1},
+		unicode.Range16{Lo: 0x119, Hi: 0x119, Stride: 0x1},
+		unicode.Range16{Lo: 0x11b, Hi: 0x11b, Stride: 0x1},
+		unicode.Range16{Lo: 0x11d, Hi: 0x11d, Stride: 0x1},
+		unicode.Range16{Lo: 0x11f, Hi: 0x11f, Stride: 0x1},
+		unicode.Range16{Lo: 0x121, Hi: 0x121, Stride: 0x1},
+		unicode.Range16{Lo: 0x123, Hi: 0x123, Stride: 0x1},
+		unicode.Range16{Lo: 0x125, Hi: 0x125, Stride: 0x1},
+		unicode.Range16{Lo: 0x127, Hi: 0x127, Stride: 0x1},
+		unicode.Range16{Lo: 0x129, Hi: 0x129, Stride: 0x1},
+		unicode.Range16{Lo: 0x12b, Hi: 0x12b, Stride: 0x1},
+		unicode.Range16{Lo: 0x12d, Hi: 0x12d, Stride: 0x1},
+		unicode.Range16{Lo: 0x12f, Hi: 0x12f, Stride: 0x1},
+		unicode.Range16{Lo: 0x131, Hi: 0x131, Stride: 0x1},
+		unicode.Range16{Lo: 0x133, Hi: 0x133, Stride: 0x1},
+		unicode.Range16{Lo: 0x135, Hi: 0x135, Stride: 0x1},
+		unicode.Range16{Lo: 0x137, Hi: 0x138, Stride: 0x1},
+		unicode.Range16{Lo: 0x13a, Hi: 0x13a, Stride: 0x1},
+		unicode.Range16{Lo: 0x13c, Hi: 0x13c, Stride: 0x1},
+		unicode.Range16{Lo: 0x13e, Hi: 0x13e, Stride: 0x1},
+		unicode.Range16{Lo: 0x140, Hi: 0x140, Stride: 0x1},
+		unicode.Range16{Lo: 0x142, Hi: 0x142, Stride: 0x1},
+		unicode.Range16{Lo: 0x144, Hi: 0x144, Stride: 0x1},
+		unicode.Range16{Lo: 0x146, Hi: 0x146, Stride: 0x1},
+		unicode.Range16{Lo: 0x148, Hi: 0x149, Stride: 0x1},
+		unicode.Range16{Lo: 0x14b, Hi: 0x14b, Stride: 0x1},
+		unicode.Range16{Lo: 0x14d, Hi: 0x14d, Stride: 0x1},
+		unicode.Range16{Lo: 0x14f, Hi: 0x14f, Stride: 0x1},
+		unicode.Range16{Lo: 0x151, Hi: 0x151, Stride: 0x1},
+		unicode.Range16{Lo: 0x153, Hi: 0x153, Stride: 0x1},
+		unicode.Range16{Lo: 0x155, Hi: 0x155, Stride: 0x1},
+		unicode.Range16{Lo: 0x157, Hi: 0x157, Stride: 0x1},
+		unicode.Range16{Lo: 0x159, Hi: 0x159, Stride: 0x1},
+		unicode.Range16{Lo: 0x15b, Hi: 0x15b, Stride: 0x1},
+		unicode.Range16{Lo: 0x15d, Hi: 0x15d, Stride: 0x1},
+		unicode.Range16{Lo: 0x15f, Hi: 0x15f, Stride: 0x1},
+		unicode.Range16{Lo: 0x161, Hi: 0x161, Stride: 0x1},
+		unicode.Range16{Lo: 0x163, Hi: 0x163, Stride: 0x1},
+		unicode.Range16{Lo: 0x165, Hi: 0x165, Stride: 0x1},
+		unicode.Range16{Lo: 0x167, Hi: 0x167, Stride: 0x1},
+		unicode.Range16{Lo: 0x169, Hi: 0x169, Stride: 0x1},
+		unicode.Range16{Lo: 0x16b, Hi: 0x16b, Stride: 0x1},
+		unicode.Range16{Lo: 0x16d, Hi: 0x16d, Stride: 0x1},
+		unicode.Range16{Lo: 0x16f, Hi: 0x16f, Stride: 0x1},
+		unicode.Range16{Lo: 0x171, Hi: 0x171, Stride: 0x1},
+		unicode.Range16{Lo: 0x173, Hi: 0x173, Stride: 0x1},
+		unicode.Range16{Lo: 0x175, Hi: 0x175, Stride: 0x1},
+		unicode.Range16{Lo: 0x177, Hi: 0x177, Stride: 0x1},
+		unicode.Range16{Lo: 0x17a, Hi: 0x17a, Stride: 0x1},
+		unicode.Range16{Lo: 0x17c, Hi: 0x17c, Stride: 0x1},
+		unicode.Range16{Lo: 0x17e, Hi: 0x180, Stride: 0x1},
+		unicode.Range16{Lo: 0x183, Hi: 0x183, Stride: 0x1},
+		unicode.Range16{Lo: 0x185, Hi: 0x185, Stride: 0x1},
+		unicode.Range16{Lo: 0x188, Hi: 0x188, Stride: 0x1},
+		unicode.Range16{Lo: 0x18c, Hi: 0x18d, Stride: 0x1},
+		unicode.Range16{Lo: 0x192, Hi: 0x192, Stride: 0x1},
+		unicode.Range16{Lo: 0x195, Hi: 0x195, Stride: 0x1},
+		unicode.Range16{Lo: 0x199, Hi: 0x19b, Stride: 0x1},
+		unicode.Range16{Lo: 0x19e, Hi: 0x19e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a1, Hi: 0x1a1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a3, Hi: 0x1a3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a5, Hi: 0x1a5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a8, Hi: 0x1a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1aa, Hi: 0x1ab, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ad, Hi: 0x1ad, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b0, Hi: 0x1b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b4, Hi: 0x1b4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b6, Hi: 0x1b6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b9, Hi: 0x1ba, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bd, Hi: 0x1bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c6, Hi: 0x1c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c9, Hi: 0x1c9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cc, Hi: 0x1cc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce, Hi: 0x1ce, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d0, Hi: 0x1d0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d2, Hi: 0x1d2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d4, Hi: 0x1d4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d6, Hi: 0x1d6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d8, Hi: 0x1d8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1da, Hi: 0x1da, Stride: 0x1},
+		unicode.Range16{Lo: 0x1dc, Hi: 0x1dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1df, Hi: 0x1df, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1, Hi: 0x1e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3, Hi: 0x1e3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5, Hi: 0x1e5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7, Hi: 0x1e7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e9, Hi: 0x1e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb, Hi: 0x1eb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed, Hi: 0x1ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef, Hi: 0x1f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f3, Hi: 0x1f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5, Hi: 0x1f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f9, Hi: 0x1f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fb, Hi: 0x1fb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd, Hi: 0x1fd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff, Hi: 0x1ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x201, Hi: 0x201, Stride: 0x1},
+		unicode.Range16{Lo: 0x203, Hi: 0x203, Stride: 0x1},
+		unicode.Range16{Lo: 0x205, Hi: 0x205, Stride: 0x1},
+		unicode.Range16{Lo: 0x207, Hi: 0x207, Stride: 0x1},
+		unicode.Range16{Lo: 0x209, Hi: 0x209, Stride: 0x1},
+		unicode.Range16{Lo: 0x20b, Hi: 0x20b, Stride: 0x1},
+		unicode.Range16{Lo: 0x20d, Hi: 0x20d, Stride: 0x1},
+		unicode.Range16{Lo: 0x20f, Hi: 0x20f, Stride: 0x1},
+		unicode.Range16{Lo: 0x211, Hi: 0x211, Stride: 0x1},
+		unicode.Range16{Lo: 0x213, Hi: 0x213, Stride: 0x1},
+		unicode.Range16{Lo: 0x215, Hi: 0x215, Stride: 0x1},
+		unicode.Range16{Lo: 0x217, Hi: 0x217, Stride: 0x1},
+		unicode.Range16{Lo: 0x219, Hi: 0x219, Stride: 0x1},
+		unicode.Range16{Lo: 0x21b, Hi: 0x21b, Stride: 0x1},
+		unicode.Range16{Lo: 0x21d, Hi: 0x21d, Stride: 0x1},
+		unicode.Range16{Lo: 0x21f, Hi: 0x21f, Stride: 0x1},
+		unicode.Range16{Lo: 0x221, Hi: 0x221, Stride: 0x1},
+		unicode.Range16{Lo: 0x223, Hi: 0x223, Stride: 0x1},
+		unicode.Range16{Lo: 0x225, Hi: 0x225, Stride: 0x1},
+		unicode.Range16{Lo: 0x227, Hi: 0x227, Stride: 0x1},
+		unicode.Range16{Lo: 0x229, Hi: 0x229, Stride: 0x1},
+		unicode.Range16{Lo: 0x22b, Hi: 0x22b, Stride: 0x1},
+		unicode.Range16{Lo: 0x22d, Hi: 0x22d, Stride: 0x1},
+		unicode.Range16{Lo: 0x22f, Hi: 0x22f, Stride: 0x1},
+		unicode.Range16{Lo: 0x231, Hi: 0x231, Stride: 0x1},
+		unicode.Range16{Lo: 0x233, Hi: 0x239, Stride: 0x1},
+		unicode.Range16{Lo: 0x23c, Hi: 0x23c, Stride: 0x1},
+		unicode.Range16{Lo: 0x23f, Hi: 0x240, Stride: 0x1},
+		unicode.Range16{Lo: 0x242, Hi: 0x242, Stride: 0x1},
+		unicode.Range16{Lo: 0x247, Hi: 0x247, Stride: 0x1},
+		unicode.Range16{Lo: 0x249, Hi: 0x249, Stride: 0x1},
+		unicode.Range16{Lo: 0x24b, Hi: 0x24b, Stride: 0x1},
+		unicode.Range16{Lo: 0x24d, Hi: 0x24d, Stride: 0x1},
+		unicode.Range16{Lo: 0x24f, Hi: 0x293, Stride: 0x1},
+		unicode.Range16{Lo: 0x295, Hi: 0x2af, Stride: 0x1},
+		unicode.Range16{Lo: 0x2b0, Hi: 0x2b8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c0, Hi: 0x2c1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e0, Hi: 0x2e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x371, Hi: 0x371, Stride: 0x1},
+		unicode.Range16{Lo: 0x373, Hi: 0x373, Stride: 0x1},
+		unicode.Range16{Lo: 0x377, Hi: 0x377, Stride: 0x1},
+		unicode.Range16{Lo: 0x37a, Hi: 0x37a, Stride: 0x1},
+		unicode.Range16{Lo: 0x37b, Hi: 0x37d, Stride: 0x1},
+		unicode.Range16{Lo: 0x390, Hi: 0x390, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ac, Hi: 0x3ce, Stride: 0x1},
+		unicode.Range16{Lo: 0x3d0, Hi: 0x3d1, Stride: 0x1},
+		unicode.Range16{Lo: 0x3d5, Hi: 0x3d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x3d9, Hi: 0x3d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x3db, Hi: 0x3db, Stride: 0x1},
+		unicode.Range16{Lo: 0x3dd, Hi: 0x3dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x3df, Hi: 0x3df, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e1, Hi: 0x3e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e3, Hi: 0x3e3, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e5, Hi: 0x3e5, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e7, Hi: 0x3e7, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e9, Hi: 0x3e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x3eb, Hi: 0x3eb, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ed, Hi: 0x3ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ef, Hi: 0x3f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f5, Hi: 0x3f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f8, Hi: 0x3f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x3fb, Hi: 0x3fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x430, Hi: 0x45f, Stride: 0x1},
+		unicode.Range16{Lo: 0x461, Hi: 0x461, Stride: 0x1},
+		unicode.Range16{Lo: 0x463, Hi: 0x463, Stride: 0x1},
+		unicode.Range16{Lo: 0x465, Hi: 0x465, Stride: 0x1},
+		unicode.Range16{Lo: 0x467, Hi: 0x467, Stride: 0x1},
+		unicode.Range16{Lo: 0x469, Hi: 0x469, Stride: 0x1},
+		unicode.Range16{Lo: 0x46b, Hi: 0x46b, Stride: 0x1},
+		unicode.Range16{Lo: 0x46d, Hi: 0x46d, Stride: 0x1},
+		unicode.Range16{Lo: 0x46f, Hi: 0x46f, Stride: 0x1},
+		unicode.Range16{Lo: 0x471, Hi: 0x471, Stride: 0x1},
+		unicode.Range16{Lo: 0x473, Hi: 0x473, Stride: 0x1},
+		unicode.Range16{Lo: 0x475, Hi: 0x475, Stride: 0x1},
+		unicode.Range16{Lo: 0x477, Hi: 0x477, Stride: 0x1},
+		unicode.Range16{Lo: 0x479, Hi: 0x479, Stride: 0x1},
+		unicode.Range16{Lo: 0x47b, Hi: 0x47b, Stride: 0x1},
+		unicode.Range16{Lo: 0x47d, Hi: 0x47d, Stride: 0x1},
+		unicode.Range16{Lo: 0x47f, Hi: 0x47f, Stride: 0x1},
+		unicode.Range16{Lo: 0x481, Hi: 0x481, Stride: 0x1},
+		unicode.Range16{Lo: 0x48b, Hi: 0x48b, Stride: 0x1},
+		unicode.Range16{Lo: 0x48d, Hi: 0x48d, Stride: 0x1},
+		unicode.Range16{Lo: 0x48f, Hi: 0x48f, Stride: 0x1},
+		unicode.Range16{Lo: 0x491, Hi: 0x491, Stride: 0x1},
+		unicode.Range16{Lo: 0x493, Hi: 0x493, Stride: 0x1},
+		unicode.Range16{Lo: 0x495, Hi: 0x495, Stride: 0x1},
+		unicode.Range16{Lo: 0x497, Hi: 0x497, Stride: 0x1},
+		unicode.Range16{Lo: 0x499, Hi: 0x499, Stride: 0x1},
+		unicode.Range16{Lo: 0x49b, Hi: 0x49b, Stride: 0x1},
+		unicode.Range16{Lo: 0x49d, Hi: 0x49d, Stride: 0x1},
+		unicode.Range16{Lo: 0x49f, Hi: 0x49f, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a1, Hi: 0x4a1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a3, Hi: 0x4a3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a5, Hi: 0x4a5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a7, Hi: 0x4a7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a9, Hi: 0x4a9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ab, Hi: 0x4ab, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ad, Hi: 0x4ad, Stride: 0x1},
+		unicode.Range16{Lo: 0x4af, Hi: 0x4af, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b1, Hi: 0x4b1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b3, Hi: 0x4b3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b5, Hi: 0x4b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b7, Hi: 0x4b7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b9, Hi: 0x4b9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4bb, Hi: 0x4bb, Stride: 0x1},
+		unicode.Range16{Lo: 0x4bd, Hi: 0x4bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x4bf, Hi: 0x4bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c2, Hi: 0x4c2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c4, Hi: 0x4c4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c6, Hi: 0x4c6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c8, Hi: 0x4c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ca, Hi: 0x4ca, Stride: 0x1},
+		unicode.Range16{Lo: 0x4cc, Hi: 0x4cc, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ce, Hi: 0x4cf, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d1, Hi: 0x4d1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d3, Hi: 0x4d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d5, Hi: 0x4d5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d7, Hi: 0x4d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d9, Hi: 0x4d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4db, Hi: 0x4db, Stride: 0x1},
+		unicode.Range16{Lo: 0x4dd, Hi: 0x4dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x4df, Hi: 0x4df, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e1, Hi: 0x4e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e3, Hi: 0x4e3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e5, Hi: 0x4e5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e7, Hi: 0x4e7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e9, Hi: 0x4e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4eb, Hi: 0x4eb, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ed, Hi: 0x4ed, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ef, Hi: 0x4ef, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f1, Hi: 0x4f1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f3, Hi: 0x4f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f5, Hi: 0x4f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f7, Hi: 0x4f7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f9, Hi: 0x4f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4fb, Hi: 0x4fb, Stride: 0x1},
+		unicode.Range16{Lo: 0x4fd, Hi: 0x4fd, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ff, Hi: 0x4ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x501, Hi: 0x501, Stride: 0x1},
+		unicode.Range16{Lo: 0x503, Hi: 0x503, Stride: 0x1},
+		unicode.Range16{Lo: 0x505, Hi: 0x505, Stride: 0x1},
+		unicode.Range16{Lo: 0x507, Hi: 0x507, Stride: 0x1},
+		unicode.Range16{Lo: 0x509, Hi: 0x509, Stride: 0x1},
+		unicode.Range16{Lo: 0x50b, Hi: 0x50b, Stride: 0x1},
+		unicode.Range16{Lo: 0x50d, Hi: 0x50d, Stride: 0x1},
+		unicode.Range16{Lo: 0x50f, Hi: 0x50f, Stride: 0x1},
+		unicode.Range16{Lo: 0x511, Hi: 0x511, Stride: 0x1},
+		unicode.Range16{Lo: 0x513, Hi: 0x513, Stride: 0x1},
+		unicode.Range16{Lo: 0x515, Hi: 0x515, Stride: 0x1},
+		unicode.Range16{Lo: 0x517, Hi: 0x517, Stride: 0x1},
+		unicode.Range16{Lo: 0x519, Hi: 0x519, Stride: 0x1},
+		unicode.Range16{Lo: 0x51b, Hi: 0x51b, Stride: 0x1},
+		unicode.Range16{Lo: 0x51d, Hi: 0x51d, Stride: 0x1},
+		unicode.Range16{Lo: 0x51f, Hi: 0x51f, Stride: 0x1},
+		unicode.Range16{Lo: 0x521, Hi: 0x521, Stride: 0x1},
+		unicode.Range16{Lo: 0x523, Hi: 0x523, Stride: 0x1},
+		unicode.Range16{Lo: 0x525, Hi: 0x525, Stride: 0x1},
+		unicode.Range16{Lo: 0x527, Hi: 0x527, Stride: 0x1},
+		unicode.Range16{Lo: 0x529, Hi: 0x529, Stride: 0x1},
+		unicode.Range16{Lo: 0x52b, Hi: 0x52b, Stride: 0x1},
+		unicode.Range16{Lo: 0x52d, Hi: 0x52d, Stride: 0x1},
+		unicode.Range16{Lo: 0x52f, Hi: 0x52f, Stride: 0x1},
+		unicode.Range16{Lo: 0x561, Hi: 0x587, Stride: 0x1},
+		unicode.Range16{Lo: 0x13f8, Hi: 0x13fd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c80, Hi: 0x1c88, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d00, Hi: 0x1d2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d2c, Hi: 0x1d6a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d6b, Hi: 0x1d77, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d78, Hi: 0x1d78, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d79, Hi: 0x1d9a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d9b, Hi: 0x1dbf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e01, Hi: 0x1e01, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e03, Hi: 0x1e03, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e05, Hi: 0x1e05, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e07, Hi: 0x1e07, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e09, Hi: 0x1e09, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0b, Hi: 0x1e0b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0d, Hi: 0x1e0d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0f, Hi: 0x1e0f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e11, Hi: 0x1e11, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e13, Hi: 0x1e13, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e15, Hi: 0x1e15, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e17, Hi: 0x1e17, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e19, Hi: 0x1e19, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1b, Hi: 0x1e1b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1d, Hi: 0x1e1d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1f, Hi: 0x1e1f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e21, Hi: 0x1e21, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e23, Hi: 0x1e23, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e25, Hi: 0x1e25, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e27, Hi: 0x1e27, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e29, Hi: 0x1e29, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2b, Hi: 0x1e2b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2d, Hi: 0x1e2d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2f, Hi: 0x1e2f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e31, Hi: 0x1e31, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e33, Hi: 0x1e33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e35, Hi: 0x1e35, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e37, Hi: 0x1e37, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e39, Hi: 0x1e39, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3b, Hi: 0x1e3b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3d, Hi: 0x1e3d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3f, Hi: 0x1e3f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e41, Hi: 0x1e41, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e43, Hi: 0x1e43, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e45, Hi: 0x1e45, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e47, Hi: 0x1e47, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e49, Hi: 0x1e49, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4b, Hi: 0x1e4b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4d, Hi: 0x1e4d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4f, Hi: 0x1e4f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e51, Hi: 0x1e51, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e53, Hi: 0x1e53, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e55, Hi: 0x1e55, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e57, Hi: 0x1e57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e59, Hi: 0x1e59, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5b, Hi: 0x1e5b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5d, Hi: 0x1e5d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5f, Hi: 0x1e5f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e61, Hi: 0x1e61, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e63, Hi: 0x1e63, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e65, Hi: 0x1e65, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e67, Hi: 0x1e67, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e69, Hi: 0x1e69, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6b, Hi: 0x1e6b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6d, Hi: 0x1e6d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6f, Hi: 0x1e6f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e71, Hi: 0x1e71, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e73, Hi: 0x1e73, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e75, Hi: 0x1e75, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e77, Hi: 0x1e77, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e79, Hi: 0x1e79, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7b, Hi: 0x1e7b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7d, Hi: 0x1e7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7f, Hi: 0x1e7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e81, Hi: 0x1e81, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e83, Hi: 0x1e83, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e85, Hi: 0x1e85, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e87, Hi: 0x1e87, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e89, Hi: 0x1e89, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8b, Hi: 0x1e8b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8d, Hi: 0x1e8d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8f, Hi: 0x1e8f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e91, Hi: 0x1e91, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e93, Hi: 0x1e93, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e95, Hi: 0x1e9d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e9f, Hi: 0x1e9f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea1, Hi: 0x1ea1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea3, Hi: 0x1ea3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea5, Hi: 0x1ea5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea7, Hi: 0x1ea7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea9, Hi: 0x1ea9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eab, Hi: 0x1eab, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ead, Hi: 0x1ead, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eaf, Hi: 0x1eaf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb1, Hi: 0x1eb1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb3, Hi: 0x1eb3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb5, Hi: 0x1eb5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb7, Hi: 0x1eb7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb9, Hi: 0x1eb9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ebb, Hi: 0x1ebb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ebd, Hi: 0x1ebd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ebf, Hi: 0x1ebf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec1, Hi: 0x1ec1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec3, Hi: 0x1ec3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec5, Hi: 0x1ec5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec7, Hi: 0x1ec7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec9, Hi: 0x1ec9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ecb, Hi: 0x1ecb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ecd, Hi: 0x1ecd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ecf, Hi: 0x1ecf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed1, Hi: 0x1ed1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed3, Hi: 0x1ed3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed5, Hi: 0x1ed5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed7, Hi: 0x1ed7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed9, Hi: 0x1ed9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1edb, Hi: 0x1edb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1edd, Hi: 0x1edd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1edf, Hi: 0x1edf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee1, Hi: 0x1ee1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee3, Hi: 0x1ee3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee5, Hi: 0x1ee5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee7, Hi: 0x1ee7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee9, Hi: 0x1ee9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eeb, Hi: 0x1eeb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eed, Hi: 0x1eed, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eef, Hi: 0x1eef, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef1, Hi: 0x1ef1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef3, Hi: 0x1ef3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef5, Hi: 0x1ef5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef7, Hi: 0x1ef7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef9, Hi: 0x1ef9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1efb, Hi: 0x1efb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1efd, Hi: 0x1efd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eff, Hi: 0x1f07, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f10, Hi: 0x1f15, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f20, Hi: 0x1f27, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f30, Hi: 0x1f37, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f40, Hi: 0x1f45, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f50, Hi: 0x1f57, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f60, Hi: 0x1f67, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f70, Hi: 0x1f7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f80, Hi: 0x1f87, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f90, Hi: 0x1f97, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fa0, Hi: 0x1fa7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fb0, Hi: 0x1fb4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fb6, Hi: 0x1fb7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fbe, Hi: 0x1fbe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc2, Hi: 0x1fc4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc6, Hi: 0x1fc7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd0, Hi: 0x1fd3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd6, Hi: 0x1fd7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fe0, Hi: 0x1fe7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff2, Hi: 0x1ff4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff6, Hi: 0x1ff7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2071, Hi: 0x2071, Stride: 0x1},
+		unicode.Range16{Lo: 0x207f, Hi: 0x207f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2090, Hi: 0x209c, Stride: 0x1},
+		unicode.Range16{Lo: 0x210a, Hi: 0x210a, Stride: 0x1},
+		unicode.Range16{Lo: 0x210e, Hi: 0x210f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2113, Hi: 0x2113, Stride: 0x1},
+		unicode.Range16{Lo: 0x212f, Hi: 0x212f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2134, Hi: 0x2134, Stride: 0x1},
+		unicode.Range16{Lo: 0x2139, Hi: 0x2139, Stride: 0x1},
+		unicode.Range16{Lo: 0x213c, Hi: 0x213d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2146, Hi: 0x2149, Stride: 0x1},
+		unicode.Range16{Lo: 0x214e, Hi: 0x214e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2170, Hi: 0x217f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2184, Hi: 0x2184, Stride: 0x1},
+		unicode.Range16{Lo: 0x24d0, Hi: 0x24e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c30, Hi: 0x2c5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c61, Hi: 0x2c61, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c65, Hi: 0x2c66, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c68, Hi: 0x2c68, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6a, Hi: 0x2c6a, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6c, Hi: 0x2c6c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c71, Hi: 0x2c71, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c73, Hi: 0x2c74, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c76, Hi: 0x2c7b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c7c, Hi: 0x2c7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c81, Hi: 0x2c81, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c83, Hi: 0x2c83, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c85, Hi: 0x2c85, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c87, Hi: 0x2c87, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c89, Hi: 0x2c89, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8b, Hi: 0x2c8b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8d, Hi: 0x2c8d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8f, Hi: 0x2c8f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c91, Hi: 0x2c91, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c93, Hi: 0x2c93, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c95, Hi: 0x2c95, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c97, Hi: 0x2c97, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c99, Hi: 0x2c99, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9b, Hi: 0x2c9b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9d, Hi: 0x2c9d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9f, Hi: 0x2c9f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca1, Hi: 0x2ca1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca3, Hi: 0x2ca3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca5, Hi: 0x2ca5, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca7, Hi: 0x2ca7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca9, Hi: 0x2ca9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cab, Hi: 0x2cab, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cad, Hi: 0x2cad, Stride: 0x1},
+		unicode.Range16{Lo: 0x2caf, Hi: 0x2caf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb1, Hi: 0x2cb1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb3, Hi: 0x2cb3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb5, Hi: 0x2cb5, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb7, Hi: 0x2cb7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb9, Hi: 0x2cb9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cbb, Hi: 0x2cbb, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cbd, Hi: 0x2cbd, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cbf, Hi: 0x2cbf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc1, Hi: 0x2cc1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc3, Hi: 0x2cc3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc5, Hi: 0x2cc5, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc7, Hi: 0x2cc7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc9, Hi: 0x2cc9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ccb, Hi: 0x2ccb, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ccd, Hi: 0x2ccd, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ccf, Hi: 0x2ccf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd1, Hi: 0x2cd1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd3, Hi: 0x2cd3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd5, Hi: 0x2cd5, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd7, Hi: 0x2cd7, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd9, Hi: 0x2cd9, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cdb, Hi: 0x2cdb, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cdd, Hi: 0x2cdd, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cdf, Hi: 0x2cdf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ce1, Hi: 0x2ce1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ce3, Hi: 0x2ce4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cec, Hi: 0x2cec, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cee, Hi: 0x2cee, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cf3, Hi: 0x2cf3, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d00, Hi: 0x2d25, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d27, Hi: 0x2d27, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d2d, Hi: 0x2d2d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa641, Hi: 0xa641, Stride: 0x1},
+		unicode.Range16{Lo: 0xa643, Hi: 0xa643, Stride: 0x1},
+		unicode.Range16{Lo: 0xa645, Hi: 0xa645, Stride: 0x1},
+		unicode.Range16{Lo: 0xa647, Hi: 0xa647, Stride: 0x1},
+		unicode.Range16{Lo: 0xa649, Hi: 0xa649, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64b, Hi: 0xa64b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64d, Hi: 0xa64d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64f, Hi: 0xa64f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa651, Hi: 0xa651, Stride: 0x1},
+		unicode.Range16{Lo: 0xa653, Hi: 0xa653, Stride: 0x1},
+		unicode.Range16{Lo: 0xa655, Hi: 0xa655, Stride: 0x1},
+		unicode.Range16{Lo: 0xa657, Hi: 0xa657, Stride: 0x1},
+		unicode.Range16{Lo: 0xa659, Hi: 0xa659, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65b, Hi: 0xa65b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65d, Hi: 0xa65d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65f, Hi: 0xa65f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa661, Hi: 0xa661, Stride: 0x1},
+		unicode.Range16{Lo: 0xa663, Hi: 0xa663, Stride: 0x1},
+		unicode.Range16{Lo: 0xa665, Hi: 0xa665, Stride: 0x1},
+		unicode.Range16{Lo: 0xa667, Hi: 0xa667, Stride: 0x1},
+		unicode.Range16{Lo: 0xa669, Hi: 0xa669, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66b, Hi: 0xa66b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66d, Hi: 0xa66d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa681, Hi: 0xa681, Stride: 0x1},
+		unicode.Range16{Lo: 0xa683, Hi: 0xa683, Stride: 0x1},
+		unicode.Range16{Lo: 0xa685, Hi: 0xa685, Stride: 0x1},
+		unicode.Range16{Lo: 0xa687, Hi: 0xa687, Stride: 0x1},
+		unicode.Range16{Lo: 0xa689, Hi: 0xa689, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68b, Hi: 0xa68b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68d, Hi: 0xa68d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68f, Hi: 0xa68f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa691, Hi: 0xa691, Stride: 0x1},
+		unicode.Range16{Lo: 0xa693, Hi: 0xa693, Stride: 0x1},
+		unicode.Range16{Lo: 0xa695, Hi: 0xa695, Stride: 0x1},
+		unicode.Range16{Lo: 0xa697, Hi: 0xa697, Stride: 0x1},
+		unicode.Range16{Lo: 0xa699, Hi: 0xa699, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69b, Hi: 0xa69b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69c, Hi: 0xa69d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa723, Hi: 0xa723, Stride: 0x1},
+		unicode.Range16{Lo: 0xa725, Hi: 0xa725, Stride: 0x1},
+		unicode.Range16{Lo: 0xa727, Hi: 0xa727, Stride: 0x1},
+		unicode.Range16{Lo: 0xa729, Hi: 0xa729, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72b, Hi: 0xa72b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72d, Hi: 0xa72d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72f, Hi: 0xa731, Stride: 0x1},
+		unicode.Range16{Lo: 0xa733, Hi: 0xa733, Stride: 0x1},
+		unicode.Range16{Lo: 0xa735, Hi: 0xa735, Stride: 0x1},
+		unicode.Range16{Lo: 0xa737, Hi: 0xa737, Stride: 0x1},
+		unicode.Range16{Lo: 0xa739, Hi: 0xa739, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73b, Hi: 0xa73b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73d, Hi: 0xa73d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73f, Hi: 0xa73f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa741, Hi: 0xa741, Stride: 0x1},
+		unicode.Range16{Lo: 0xa743, Hi: 0xa743, Stride: 0x1},
+		unicode.Range16{Lo: 0xa745, Hi: 0xa745, Stride: 0x1},
+		unicode.Range16{Lo: 0xa747, Hi: 0xa747, Stride: 0x1},
+		unicode.Range16{Lo: 0xa749, Hi: 0xa749, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74b, Hi: 0xa74b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74d, Hi: 0xa74d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74f, Hi: 0xa74f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa751, Hi: 0xa751, Stride: 0x1},
+		unicode.Range16{Lo: 0xa753, Hi: 0xa753, Stride: 0x1},
+		unicode.Range16{Lo: 0xa755, Hi: 0xa755, Stride: 0x1},
+		unicode.Range16{Lo: 0xa757, Hi: 0xa757, Stride: 0x1},
+		unicode.Range16{Lo: 0xa759, Hi: 0xa759, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75b, Hi: 0xa75b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75d, Hi: 0xa75d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75f, Hi: 0xa75f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa761, Hi: 0xa761, Stride: 0x1},
+		unicode.Range16{Lo: 0xa763, Hi: 0xa763, Stride: 0x1},
+		unicode.Range16{Lo: 0xa765, Hi: 0xa765, Stride: 0x1},
+		unicode.Range16{Lo: 0xa767, Hi: 0xa767, Stride: 0x1},
+		unicode.Range16{Lo: 0xa769, Hi: 0xa769, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76b, Hi: 0xa76b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76d, Hi: 0xa76d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76f, Hi: 0xa76f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa770, Hi: 0xa770, Stride: 0x1},
+		unicode.Range16{Lo: 0xa771, Hi: 0xa778, Stride: 0x1},
+		unicode.Range16{Lo: 0xa77a, Hi: 0xa77a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa77c, Hi: 0xa77c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa77f, Hi: 0xa77f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa781, Hi: 0xa781, Stride: 0x1},
+		unicode.Range16{Lo: 0xa783, Hi: 0xa783, Stride: 0x1},
+		unicode.Range16{Lo: 0xa785, Hi: 0xa785, Stride: 0x1},
+		unicode.Range16{Lo: 0xa787, Hi: 0xa787, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78c, Hi: 0xa78c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78e, Hi: 0xa78e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa791, Hi: 0xa791, Stride: 0x1},
+		unicode.Range16{Lo: 0xa793, Hi: 0xa795, Stride: 0x1},
+		unicode.Range16{Lo: 0xa797, Hi: 0xa797, Stride: 0x1},
+		unicode.Range16{Lo: 0xa799, Hi: 0xa799, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79b, Hi: 0xa79b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79d, Hi: 0xa79d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79f, Hi: 0xa79f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a1, Hi: 0xa7a1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a3, Hi: 0xa7a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a5, Hi: 0xa7a5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a7, Hi: 0xa7a7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a9, Hi: 0xa7a9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7b5, Hi: 0xa7b5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7b7, Hi: 0xa7b7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7f8, Hi: 0xa7f9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7fa, Hi: 0xa7fa, Stride: 0x1},
+		unicode.Range16{Lo: 0xab30, Hi: 0xab5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xab5c, Hi: 0xab5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xab60, Hi: 0xab65, Stride: 0x1},
+		unicode.Range16{Lo: 0xab70, Hi: 0xabbf, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb00, Hi: 0xfb06, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb13, Hi: 0xfb17, Stride: 0x1},
+		unicode.Range16{Lo: 0xff41, Hi: 0xff5a, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x10428, Hi: 0x1044f, Stride: 0x1},
+		unicode.Range32{Lo: 0x104d8, Hi: 0x104fb, Stride: 0x1},
+		unicode.Range32{Lo: 0x10cc0, Hi: 0x10cf2, Stride: 0x1},
+		unicode.Range32{Lo: 0x118c0, Hi: 0x118df, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d41a, Hi: 0x1d433, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d44e, Hi: 0x1d454, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d456, Hi: 0x1d467, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d482, Hi: 0x1d49b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4b6, Hi: 0x1d4b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4bb, Hi: 0x1d4bb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4bd, Hi: 0x1d4c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4c5, Hi: 0x1d4cf, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4ea, Hi: 0x1d503, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d51e, Hi: 0x1d537, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d552, Hi: 0x1d56b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d586, Hi: 0x1d59f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d5ba, Hi: 0x1d5d3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d5ee, Hi: 0x1d607, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d622, Hi: 0x1d63b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d656, Hi: 0x1d66f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d68a, Hi: 0x1d6a5, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6c2, Hi: 0x1d6da, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6dc, Hi: 0x1d6e1, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6fc, Hi: 0x1d714, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d716, Hi: 0x1d71b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d736, Hi: 0x1d74e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d750, Hi: 0x1d755, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d770, Hi: 0x1d788, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d78a, Hi: 0x1d78f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7aa, Hi: 0x1d7c2, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7c4, Hi: 0x1d7c9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7cb, Hi: 0x1d7cb, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e922, Hi: 0x1e943, Stride: 0x1},
+	},
+	LatinOffset: 6,
+}
+
+var _SentenceNumeric = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x30, Hi: 0x39, Stride: 0x1},
+		unicode.Range16{Lo: 0x660, Hi: 0x669, Stride: 0x1},
+		unicode.Range16{Lo: 0x66b, Hi: 0x66c, Stride: 0x1},
+		unicode.Range16{Lo: 0x6f0, Hi: 0x6f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x7c0, Hi: 0x7c9, Stride: 0x1},
+		unicode.Range16{Lo: 0x966, Hi: 0x96f, Stride: 0x1},
+		unicode.Range16{Lo: 0x9e6, Hi: 0x9ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66, Hi: 0xa6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xae6, Hi: 0xaef, Stride: 0x1},
+		unicode.Range16{Lo: 0xb66, Hi: 0xb6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xbe6, Hi: 0xbef, Stride: 0x1},
+		unicode.Range16{Lo: 0xc66, Hi: 0xc6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xce6, Hi: 0xcef, Stride: 0x1},
+		unicode.Range16{Lo: 0xd66, Hi: 0xd6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xde6, Hi: 0xdef, Stride: 0x1},
+		unicode.Range16{Lo: 0xe50, Hi: 0xe59, Stride: 0x1},
+		unicode.Range16{Lo: 0xed0, Hi: 0xed9, Stride: 0x1},
+		unicode.Range16{Lo: 0xf20, Hi: 0xf29, Stride: 0x1},
+		unicode.Range16{Lo: 0x1040, Hi: 0x1049, Stride: 0x1},
+		unicode.Range16{Lo: 0x1090, Hi: 0x1099, Stride: 0x1},
+		unicode.Range16{Lo: 0x17e0, Hi: 0x17e9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1810, Hi: 0x1819, Stride: 0x1},
+		unicode.Range16{Lo: 0x1946, Hi: 0x194f, Stride: 0x1},
+		unicode.Range16{Lo: 0x19d0, Hi: 0x19d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a80, Hi: 0x1a89, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a90, Hi: 0x1a99, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b50, Hi: 0x1b59, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bb0, Hi: 0x1bb9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c40, Hi: 0x1c49, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c50, Hi: 0x1c59, Stride: 0x1},
+		unicode.Range16{Lo: 0xa620, Hi: 0xa629, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8d0, Hi: 0xa8d9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa900, Hi: 0xa909, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9d0, Hi: 0xa9d9, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9f0, Hi: 0xa9f9, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa50, Hi: 0xaa59, Stride: 0x1},
+		unicode.Range16{Lo: 0xabf0, Hi: 0xabf9, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x104a0, Hi: 0x104a9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11066, Hi: 0x1106f, Stride: 0x1},
+		unicode.Range32{Lo: 0x110f0, Hi: 0x110f9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11136, Hi: 0x1113f, Stride: 0x1},
+		unicode.Range32{Lo: 0x111d0, Hi: 0x111d9, Stride: 0x1},
+		unicode.Range32{Lo: 0x112f0, Hi: 0x112f9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11450, Hi: 0x11459, Stride: 0x1},
+		unicode.Range32{Lo: 0x114d0, Hi: 0x114d9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11650, Hi: 0x11659, Stride: 0x1},
+		unicode.Range32{Lo: 0x116c0, Hi: 0x116c9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11730, Hi: 0x11739, Stride: 0x1},
+		unicode.Range32{Lo: 0x118e0, Hi: 0x118e9, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c50, Hi: 0x11c59, Stride: 0x1},
+		unicode.Range32{Lo: 0x16a60, Hi: 0x16a69, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b50, Hi: 0x16b59, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7ce, Hi: 0x1d7ff, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e950, Hi: 0x1e959, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceOLetter = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x1bb, Hi: 0x1bb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c0, Hi: 0x1c3, Stride: 0x1},
+		unicode.Range16{Lo: 0x294, Hi: 0x294, Stride: 0x1},
+		unicode.Range16{Lo: 0x2b9, Hi: 0x2bf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6, Hi: 0x2d1, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ec, Hi: 0x2ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ee, Hi: 0x2ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x374, Hi: 0x374, Stride: 0x1},
+		unicode.Range16{Lo: 0x559, Hi: 0x559, Stride: 0x1},
+		unicode.Range16{Lo: 0x5d0, Hi: 0x5ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x5f0, Hi: 0x5f2, Stride: 0x1},
+		unicode.Range16{Lo: 0x5f3, Hi: 0x5f3, Stride: 0x1},
+		unicode.Range16{Lo: 0x620, Hi: 0x63f, Stride: 0x1},
+		unicode.Range16{Lo: 0x640, Hi: 0x640, Stride: 0x1},
+		unicode.Range16{Lo: 0x641, Hi: 0x64a, Stride: 0x1},
+		unicode.Range16{Lo: 0x66e, Hi: 0x66f, Stride: 0x1},
+		unicode.Range16{Lo: 0x671, Hi: 0x6d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d5, Hi: 0x6d5, Stride: 0x1},
+		unicode.Range16{Lo: 0x6e5, Hi: 0x6e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ee, Hi: 0x6ef, Stride: 0x1},
+		unicode.Range16{Lo: 0x6fa, Hi: 0x6fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x6ff, Hi: 0x6ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x710, Hi: 0x710, Stride: 0x1},
+		unicode.Range16{Lo: 0x712, Hi: 0x72f, Stride: 0x1},
+		unicode.Range16{Lo: 0x74d, Hi: 0x7a5, Stride: 0x1},
+		unicode.Range16{Lo: 0x7b1, Hi: 0x7b1, Stride: 0x1},
+		unicode.Range16{Lo: 0x7ca, Hi: 0x7ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f4, Hi: 0x7f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x7fa, Hi: 0x7fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x800, Hi: 0x815, Stride: 0x1},
+		unicode.Range16{Lo: 0x81a, Hi: 0x81a, Stride: 0x1},
+		unicode.Range16{Lo: 0x824, Hi: 0x824, Stride: 0x1},
+		unicode.Range16{Lo: 0x828, Hi: 0x828, Stride: 0x1},
+		unicode.Range16{Lo: 0x840, Hi: 0x858, Stride: 0x1},
+		unicode.Range16{Lo: 0x8a0, Hi: 0x8b4, Stride: 0x1},
+		unicode.Range16{Lo: 0x8b6, Hi: 0x8bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x904, Hi: 0x939, Stride: 0x1},
+		unicode.Range16{Lo: 0x93d, Hi: 0x93d, Stride: 0x1},
+		unicode.Range16{Lo: 0x950, Hi: 0x950, Stride: 0x1},
+		unicode.Range16{Lo: 0x958, Hi: 0x961, Stride: 0x1},
+		unicode.Range16{Lo: 0x971, Hi: 0x971, Stride: 0x1},
+		unicode.Range16{Lo: 0x972, Hi: 0x980, Stride: 0x1},
+		unicode.Range16{Lo: 0x985, Hi: 0x98c, Stride: 0x1},
+		unicode.Range16{Lo: 0x98f, Hi: 0x990, Stride: 0x1},
+		unicode.Range16{Lo: 0x993, Hi: 0x9a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x9aa, Hi: 0x9b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x9b2, Hi: 0x9b2, Stride: 0x1},
+		unicode.Range16{Lo: 0x9b6, Hi: 0x9b9, Stride: 0x1},
+		unicode.Range16{Lo: 0x9bd, Hi: 0x9bd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9ce, Hi: 0x9ce, Stride: 0x1},
+		unicode.Range16{Lo: 0x9dc, Hi: 0x9dd, Stride: 0x1},
+		unicode.Range16{Lo: 0x9df, Hi: 0x9e1, Stride: 0x1},
+		unicode.Range16{Lo: 0x9f0, Hi: 0x9f1, Stride: 0x1},
+		unicode.Range16{Lo: 0xa05, Hi: 0xa0a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa0f, Hi: 0xa10, Stride: 0x1},
+		unicode.Range16{Lo: 0xa13, Hi: 0xa28, Stride: 0x1},
+		unicode.Range16{Lo: 0xa2a, Hi: 0xa30, Stride: 0x1},
+		unicode.Range16{Lo: 0xa32, Hi: 0xa33, Stride: 0x1},
+		unicode.Range16{Lo: 0xa35, Hi: 0xa36, Stride: 0x1},
+		unicode.Range16{Lo: 0xa38, Hi: 0xa39, Stride: 0x1},
+		unicode.Range16{Lo: 0xa59, Hi: 0xa5c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa5e, Hi: 0xa5e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72, Hi: 0xa74, Stride: 0x1},
+		unicode.Range16{Lo: 0xa85, Hi: 0xa8d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8f, Hi: 0xa91, Stride: 0x1},
+		unicode.Range16{Lo: 0xa93, Hi: 0xaa8, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaa, Hi: 0xab0, Stride: 0x1},
+		unicode.Range16{Lo: 0xab2, Hi: 0xab3, Stride: 0x1},
+		unicode.Range16{Lo: 0xab5, Hi: 0xab9, Stride: 0x1},
+		unicode.Range16{Lo: 0xabd, Hi: 0xabd, Stride: 0x1},
+		unicode.Range16{Lo: 0xad0, Hi: 0xad0, Stride: 0x1},
+		unicode.Range16{Lo: 0xae0, Hi: 0xae1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaf9, Hi: 0xaf9, Stride: 0x1},
+		unicode.Range16{Lo: 0xb05, Hi: 0xb0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb0f, Hi: 0xb10, Stride: 0x1},
+		unicode.Range16{Lo: 0xb13, Hi: 0xb28, Stride: 0x1},
+		unicode.Range16{Lo: 0xb2a, Hi: 0xb30, Stride: 0x1},
+		unicode.Range16{Lo: 0xb32, Hi: 0xb33, Stride: 0x1},
+		unicode.Range16{Lo: 0xb35, Hi: 0xb39, Stride: 0x1},
+		unicode.Range16{Lo: 0xb3d, Hi: 0xb3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5c, Hi: 0xb5d, Stride: 0x1},
+		unicode.Range16{Lo: 0xb5f, Hi: 0xb61, Stride: 0x1},
+		unicode.Range16{Lo: 0xb71, Hi: 0xb71, Stride: 0x1},
+		unicode.Range16{Lo: 0xb83, Hi: 0xb83, Stride: 0x1},
+		unicode.Range16{Lo: 0xb85, Hi: 0xb8a, Stride: 0x1},
+		unicode.Range16{Lo: 0xb8e, Hi: 0xb90, Stride: 0x1},
+		unicode.Range16{Lo: 0xb92, Hi: 0xb95, Stride: 0x1},
+		unicode.Range16{Lo: 0xb99, Hi: 0xb9a, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9c, Hi: 0xb9c, Stride: 0x1},
+		unicode.Range16{Lo: 0xb9e, Hi: 0xb9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xba3, Hi: 0xba4, Stride: 0x1},
+		unicode.Range16{Lo: 0xba8, Hi: 0xbaa, Stride: 0x1},
+		unicode.Range16{Lo: 0xbae, Hi: 0xbb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xbd0, Hi: 0xbd0, Stride: 0x1},
+		unicode.Range16{Lo: 0xc05, Hi: 0xc0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0e, Hi: 0xc10, Stride: 0x1},
+		unicode.Range16{Lo: 0xc12, Hi: 0xc28, Stride: 0x1},
+		unicode.Range16{Lo: 0xc2a, Hi: 0xc39, Stride: 0x1},
+		unicode.Range16{Lo: 0xc3d, Hi: 0xc3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xc58, Hi: 0xc5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xc60, Hi: 0xc61, Stride: 0x1},
+		unicode.Range16{Lo: 0xc80, Hi: 0xc80, Stride: 0x1},
+		unicode.Range16{Lo: 0xc85, Hi: 0xc8c, Stride: 0x1},
+		unicode.Range16{Lo: 0xc8e, Hi: 0xc90, Stride: 0x1},
+		unicode.Range16{Lo: 0xc92, Hi: 0xca8, Stride: 0x1},
+		unicode.Range16{Lo: 0xcaa, Hi: 0xcb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xcb5, Hi: 0xcb9, Stride: 0x1},
+		unicode.Range16{Lo: 0xcbd, Hi: 0xcbd, Stride: 0x1},
+		unicode.Range16{Lo: 0xcde, Hi: 0xcde, Stride: 0x1},
+		unicode.Range16{Lo: 0xce0, Hi: 0xce1, Stride: 0x1},
+		unicode.Range16{Lo: 0xcf1, Hi: 0xcf2, Stride: 0x1},
+		unicode.Range16{Lo: 0xd05, Hi: 0xd0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xd0e, Hi: 0xd10, Stride: 0x1},
+		unicode.Range16{Lo: 0xd12, Hi: 0xd3a, Stride: 0x1},
+		unicode.Range16{Lo: 0xd3d, Hi: 0xd3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xd4e, Hi: 0xd4e, Stride: 0x1},
+		unicode.Range16{Lo: 0xd54, Hi: 0xd56, Stride: 0x1},
+		unicode.Range16{Lo: 0xd5f, Hi: 0xd61, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7a, Hi: 0xd7f, Stride: 0x1},
+		unicode.Range16{Lo: 0xd85, Hi: 0xd96, Stride: 0x1},
+		unicode.Range16{Lo: 0xd9a, Hi: 0xdb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xdb3, Hi: 0xdbb, Stride: 0x1},
+		unicode.Range16{Lo: 0xdbd, Hi: 0xdbd, Stride: 0x1},
+		unicode.Range16{Lo: 0xdc0, Hi: 0xdc6, Stride: 0x1},
+		unicode.Range16{Lo: 0xe01, Hi: 0xe30, Stride: 0x1},
+		unicode.Range16{Lo: 0xe32, Hi: 0xe33, Stride: 0x1},
+		unicode.Range16{Lo: 0xe40, Hi: 0xe45, Stride: 0x1},
+		unicode.Range16{Lo: 0xe46, Hi: 0xe46, Stride: 0x1},
+		unicode.Range16{Lo: 0xe81, Hi: 0xe82, Stride: 0x1},
+		unicode.Range16{Lo: 0xe84, Hi: 0xe84, Stride: 0x1},
+		unicode.Range16{Lo: 0xe87, Hi: 0xe88, Stride: 0x1},
+		unicode.Range16{Lo: 0xe8a, Hi: 0xe8a, Stride: 0x1},
+		unicode.Range16{Lo: 0xe8d, Hi: 0xe8d, Stride: 0x1},
+		unicode.Range16{Lo: 0xe94, Hi: 0xe97, Stride: 0x1},
+		unicode.Range16{Lo: 0xe99, Hi: 0xe9f, Stride: 0x1},
+		unicode.Range16{Lo: 0xea1, Hi: 0xea3, Stride: 0x1},
+		unicode.Range16{Lo: 0xea5, Hi: 0xea5, Stride: 0x1},
+		unicode.Range16{Lo: 0xea7, Hi: 0xea7, Stride: 0x1},
+		unicode.Range16{Lo: 0xeaa, Hi: 0xeab, Stride: 0x1},
+		unicode.Range16{Lo: 0xead, Hi: 0xeb0, Stride: 0x1},
+		unicode.Range16{Lo: 0xeb2, Hi: 0xeb3, Stride: 0x1},
+		unicode.Range16{Lo: 0xebd, Hi: 0xebd, Stride: 0x1},
+		unicode.Range16{Lo: 0xec0, Hi: 0xec4, Stride: 0x1},
+		unicode.Range16{Lo: 0xec6, Hi: 0xec6, Stride: 0x1},
+		unicode.Range16{Lo: 0xedc, Hi: 0xedf, Stride: 0x1},
+		unicode.Range16{Lo: 0xf00, Hi: 0xf00, Stride: 0x1},
+		unicode.Range16{Lo: 0xf40, Hi: 0xf47, Stride: 0x1},
+		unicode.Range16{Lo: 0xf49, Hi: 0xf6c, Stride: 0x1},
+		unicode.Range16{Lo: 0xf88, Hi: 0xf8c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1000, Hi: 0x102a, Stride: 0x1},
+		unicode.Range16{Lo: 0x103f, Hi: 0x103f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1050, Hi: 0x1055, Stride: 0x1},
+		unicode.Range16{Lo: 0x105a, Hi: 0x105d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1061, Hi: 0x1061, Stride: 0x1},
+		unicode.Range16{Lo: 0x1065, Hi: 0x1066, Stride: 0x1},
+		unicode.Range16{Lo: 0x106e, Hi: 0x1070, Stride: 0x1},
+		unicode.Range16{Lo: 0x1075, Hi: 0x1081, Stride: 0x1},
+		unicode.Range16{Lo: 0x108e, Hi: 0x108e, Stride: 0x1},
+		unicode.Range16{Lo: 0x10d0, Hi: 0x10fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x10fc, Hi: 0x10fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x10fd, Hi: 0x1248, Stride: 0x1},
+		unicode.Range16{Lo: 0x124a, Hi: 0x124d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1250, Hi: 0x1256, Stride: 0x1},
+		unicode.Range16{Lo: 0x1258, Hi: 0x1258, Stride: 0x1},
+		unicode.Range16{Lo: 0x125a, Hi: 0x125d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1260, Hi: 0x1288, Stride: 0x1},
+		unicode.Range16{Lo: 0x128a, Hi: 0x128d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1290, Hi: 0x12b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x12b2, Hi: 0x12b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x12b8, Hi: 0x12be, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c0, Hi: 0x12c0, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c2, Hi: 0x12c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c8, Hi: 0x12d6, Stride: 0x1},
+		unicode.Range16{Lo: 0x12d8, Hi: 0x1310, Stride: 0x1},
+		unicode.Range16{Lo: 0x1312, Hi: 0x1315, Stride: 0x1},
+		unicode.Range16{Lo: 0x1318, Hi: 0x135a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1380, Hi: 0x138f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1401, Hi: 0x166c, Stride: 0x1},
+		unicode.Range16{Lo: 0x166f, Hi: 0x167f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1681, Hi: 0x169a, Stride: 0x1},
+		unicode.Range16{Lo: 0x16a0, Hi: 0x16ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x16ee, Hi: 0x16f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x16f1, Hi: 0x16f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1700, Hi: 0x170c, Stride: 0x1},
+		unicode.Range16{Lo: 0x170e, Hi: 0x1711, Stride: 0x1},
+		unicode.Range16{Lo: 0x1720, Hi: 0x1731, Stride: 0x1},
+		unicode.Range16{Lo: 0x1740, Hi: 0x1751, Stride: 0x1},
+		unicode.Range16{Lo: 0x1760, Hi: 0x176c, Stride: 0x1},
+		unicode.Range16{Lo: 0x176e, Hi: 0x1770, Stride: 0x1},
+		unicode.Range16{Lo: 0x1780, Hi: 0x17b3, Stride: 0x1},
+		unicode.Range16{Lo: 0x17d7, Hi: 0x17d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x17dc, Hi: 0x17dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1820, Hi: 0x1842, Stride: 0x1},
+		unicode.Range16{Lo: 0x1843, Hi: 0x1843, Stride: 0x1},
+		unicode.Range16{Lo: 0x1844, Hi: 0x1877, Stride: 0x1},
+		unicode.Range16{Lo: 0x1880, Hi: 0x1884, Stride: 0x1},
+		unicode.Range16{Lo: 0x1887, Hi: 0x18a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x18aa, Hi: 0x18aa, Stride: 0x1},
+		unicode.Range16{Lo: 0x18b0, Hi: 0x18f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1900, Hi: 0x191e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1950, Hi: 0x196d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1970, Hi: 0x1974, Stride: 0x1},
+		unicode.Range16{Lo: 0x1980, Hi: 0x19ab, Stride: 0x1},
+		unicode.Range16{Lo: 0x19b0, Hi: 0x19c9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a00, Hi: 0x1a16, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a20, Hi: 0x1a54, Stride: 0x1},
+		unicode.Range16{Lo: 0x1aa7, Hi: 0x1aa7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b05, Hi: 0x1b33, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b45, Hi: 0x1b4b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b83, Hi: 0x1ba0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bae, Hi: 0x1baf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bba, Hi: 0x1be5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c00, Hi: 0x1c23, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c4d, Hi: 0x1c4f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c5a, Hi: 0x1c77, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c78, Hi: 0x1c7d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ce9, Hi: 0x1cec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cee, Hi: 0x1cf1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf5, Hi: 0x1cf6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2135, Hi: 0x2138, Stride: 0x1},
+		unicode.Range16{Lo: 0x2180, Hi: 0x2182, Stride: 0x1},
+		unicode.Range16{Lo: 0x2185, Hi: 0x2188, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d30, Hi: 0x2d67, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d6f, Hi: 0x2d6f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d80, Hi: 0x2d96, Stride: 0x1},
+		unicode.Range16{Lo: 0x2da0, Hi: 0x2da6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2da8, Hi: 0x2dae, Stride: 0x1},
+		unicode.Range16{Lo: 0x2db0, Hi: 0x2db6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2db8, Hi: 0x2dbe, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dc0, Hi: 0x2dc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dc8, Hi: 0x2dce, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dd0, Hi: 0x2dd6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2dd8, Hi: 0x2dde, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e2f, Hi: 0x2e2f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3005, Hi: 0x3005, Stride: 0x1},
+		unicode.Range16{Lo: 0x3006, Hi: 0x3006, Stride: 0x1},
+		unicode.Range16{Lo: 0x3007, Hi: 0x3007, Stride: 0x1},
+		unicode.Range16{Lo: 0x3021, Hi: 0x3029, Stride: 0x1},
+		unicode.Range16{Lo: 0x3031, Hi: 0x3035, Stride: 0x1},
+		unicode.Range16{Lo: 0x3038, Hi: 0x303a, Stride: 0x1},
+		unicode.Range16{Lo: 0x303b, Hi: 0x303b, Stride: 0x1},
+		unicode.Range16{Lo: 0x303c, Hi: 0x303c, Stride: 0x1},
+		unicode.Range16{Lo: 0x3041, Hi: 0x3096, Stride: 0x1},
+		unicode.Range16{Lo: 0x309d, Hi: 0x309e, Stride: 0x1},
+		unicode.Range16{Lo: 0x309f, Hi: 0x309f, Stride: 0x1},
+		unicode.Range16{Lo: 0x30a1, Hi: 0x30fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x30fc, Hi: 0x30fe, Stride: 0x1},
+		unicode.Range16{Lo: 0x30ff, Hi: 0x30ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x3105, Hi: 0x312d, Stride: 0x1},
+		unicode.Range16{Lo: 0x3131, Hi: 0x318e, Stride: 0x1},
+		unicode.Range16{Lo: 0x31a0, Hi: 0x31ba, Stride: 0x1},
+		unicode.Range16{Lo: 0x31f0, Hi: 0x31ff, Stride: 0x1},
+		unicode.Range16{Lo: 0x3400, Hi: 0x4db5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e00, Hi: 0x9fd5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa000, Hi: 0xa014, Stride: 0x1},
+		unicode.Range16{Lo: 0xa015, Hi: 0xa015, Stride: 0x1},
+		unicode.Range16{Lo: 0xa016, Hi: 0xa48c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4d0, Hi: 0xa4f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4f8, Hi: 0xa4fd, Stride: 0x1},
+		unicode.Range16{Lo: 0xa500, Hi: 0xa60b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa60c, Hi: 0xa60c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa610, Hi: 0xa61f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa62a, Hi: 0xa62b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66e, Hi: 0xa66e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa67f, Hi: 0xa67f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6a0, Hi: 0xa6e5, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6e6, Hi: 0xa6ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xa717, Hi: 0xa71f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa788, Hi: 0xa788, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78f, Hi: 0xa78f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7f7, Hi: 0xa7f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7fb, Hi: 0xa801, Stride: 0x1},
+		unicode.Range16{Lo: 0xa803, Hi: 0xa805, Stride: 0x1},
+		unicode.Range16{Lo: 0xa807, Hi: 0xa80a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa80c, Hi: 0xa822, Stride: 0x1},
+		unicode.Range16{Lo: 0xa840, Hi: 0xa873, Stride: 0x1},
+		unicode.Range16{Lo: 0xa882, Hi: 0xa8b3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8f2, Hi: 0xa8f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8fb, Hi: 0xa8fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8fd, Hi: 0xa8fd, Stride: 0x1},
+		unicode.Range16{Lo: 0xa90a, Hi: 0xa925, Stride: 0x1},
+		unicode.Range16{Lo: 0xa930, Hi: 0xa946, Stride: 0x1},
+		unicode.Range16{Lo: 0xa960, Hi: 0xa97c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa984, Hi: 0xa9b2, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9cf, Hi: 0xa9cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e0, Hi: 0xa9e4, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e6, Hi: 0xa9e6, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9e7, Hi: 0xa9ef, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9fa, Hi: 0xa9fe, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa00, Hi: 0xaa28, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa40, Hi: 0xaa42, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa44, Hi: 0xaa4b, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa60, Hi: 0xaa6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa70, Hi: 0xaa70, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa71, Hi: 0xaa76, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7a, Hi: 0xaa7a, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa7e, Hi: 0xaaaf, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab1, Hi: 0xaab1, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab5, Hi: 0xaab6, Stride: 0x1},
+		unicode.Range16{Lo: 0xaab9, Hi: 0xaabd, Stride: 0x1},
+		unicode.Range16{Lo: 0xaac0, Hi: 0xaac0, Stride: 0x1},
+		unicode.Range16{Lo: 0xaac2, Hi: 0xaac2, Stride: 0x1},
+		unicode.Range16{Lo: 0xaadb, Hi: 0xaadc, Stride: 0x1},
+		unicode.Range16{Lo: 0xaadd, Hi: 0xaadd, Stride: 0x1},
+		unicode.Range16{Lo: 0xaae0, Hi: 0xaaea, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf2, Hi: 0xaaf2, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf3, Hi: 0xaaf4, Stride: 0x1},
+		unicode.Range16{Lo: 0xab01, Hi: 0xab06, Stride: 0x1},
+		unicode.Range16{Lo: 0xab09, Hi: 0xab0e, Stride: 0x1},
+		unicode.Range16{Lo: 0xab11, Hi: 0xab16, Stride: 0x1},
+		unicode.Range16{Lo: 0xab20, Hi: 0xab26, Stride: 0x1},
+		unicode.Range16{Lo: 0xab28, Hi: 0xab2e, Stride: 0x1},
+		unicode.Range16{Lo: 0xabc0, Hi: 0xabe2, Stride: 0x1},
+		unicode.Range16{Lo: 0xac00, Hi: 0xd7a3, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7b0, Hi: 0xd7c6, Stride: 0x1},
+		unicode.Range16{Lo: 0xd7cb, Hi: 0xd7fb, Stride: 0x1},
+		unicode.Range16{Lo: 0xf900, Hi: 0xfa6d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfa70, Hi: 0xfad9, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1d, Hi: 0xfb1d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb1f, Hi: 0xfb28, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb2a, Hi: 0xfb36, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb38, Hi: 0xfb3c, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb3e, Hi: 0xfb3e, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb40, Hi: 0xfb41, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb43, Hi: 0xfb44, Stride: 0x1},
+		unicode.Range16{Lo: 0xfb46, Hi: 0xfbb1, Stride: 0x1},
+		unicode.Range16{Lo: 0xfbd3, Hi: 0xfd3d, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd50, Hi: 0xfd8f, Stride: 0x1},
+		unicode.Range16{Lo: 0xfd92, Hi: 0xfdc7, Stride: 0x1},
+		unicode.Range16{Lo: 0xfdf0, Hi: 0xfdfb, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe70, Hi: 0xfe74, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe76, Hi: 0xfefc, Stride: 0x1},
+		unicode.Range16{Lo: 0xff66, Hi: 0xff6f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff70, Hi: 0xff70, Stride: 0x1},
+		unicode.Range16{Lo: 0xff71, Hi: 0xff9d, Stride: 0x1},
+		unicode.Range16{Lo: 0xffa0, Hi: 0xffbe, Stride: 0x1},
+		unicode.Range16{Lo: 0xffc2, Hi: 0xffc7, Stride: 0x1},
+		unicode.Range16{Lo: 0xffca, Hi: 0xffcf, Stride: 0x1},
+		unicode.Range16{Lo: 0xffd2, Hi: 0xffd7, Stride: 0x1},
+		unicode.Range16{Lo: 0xffda, Hi: 0xffdc, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x10000, Hi: 0x1000b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1000d, Hi: 0x10026, Stride: 0x1},
+		unicode.Range32{Lo: 0x10028, Hi: 0x1003a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1003c, Hi: 0x1003d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1003f, Hi: 0x1004d, Stride: 0x1},
+		unicode.Range32{Lo: 0x10050, Hi: 0x1005d, Stride: 0x1},
+		unicode.Range32{Lo: 0x10080, Hi: 0x100fa, Stride: 0x1},
+		unicode.Range32{Lo: 0x10140, Hi: 0x10174, Stride: 0x1},
+		unicode.Range32{Lo: 0x10280, Hi: 0x1029c, Stride: 0x1},
+		unicode.Range32{Lo: 0x102a0, Hi: 0x102d0, Stride: 0x1},
+		unicode.Range32{Lo: 0x10300, Hi: 0x1031f, Stride: 0x1},
+		unicode.Range32{Lo: 0x10330, Hi: 0x10340, Stride: 0x1},
+		unicode.Range32{Lo: 0x10341, Hi: 0x10341, Stride: 0x1},
+		unicode.Range32{Lo: 0x10342, Hi: 0x10349, Stride: 0x1},
+		unicode.Range32{Lo: 0x1034a, Hi: 0x1034a, Stride: 0x1},
+		unicode.Range32{Lo: 0x10350, Hi: 0x10375, Stride: 0x1},
+		unicode.Range32{Lo: 0x10380, Hi: 0x1039d, Stride: 0x1},
+		unicode.Range32{Lo: 0x103a0, Hi: 0x103c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x103c8, Hi: 0x103cf, Stride: 0x1},
+		unicode.Range32{Lo: 0x103d1, Hi: 0x103d5, Stride: 0x1},
+		unicode.Range32{Lo: 0x10450, Hi: 0x1049d, Stride: 0x1},
+		unicode.Range32{Lo: 0x10500, Hi: 0x10527, Stride: 0x1},
+		unicode.Range32{Lo: 0x10530, Hi: 0x10563, Stride: 0x1},
+		unicode.Range32{Lo: 0x10600, Hi: 0x10736, Stride: 0x1},
+		unicode.Range32{Lo: 0x10740, Hi: 0x10755, Stride: 0x1},
+		unicode.Range32{Lo: 0x10760, Hi: 0x10767, Stride: 0x1},
+		unicode.Range32{Lo: 0x10800, Hi: 0x10805, Stride: 0x1},
+		unicode.Range32{Lo: 0x10808, Hi: 0x10808, Stride: 0x1},
+		unicode.Range32{Lo: 0x1080a, Hi: 0x10835, Stride: 0x1},
+		unicode.Range32{Lo: 0x10837, Hi: 0x10838, Stride: 0x1},
+		unicode.Range32{Lo: 0x1083c, Hi: 0x1083c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1083f, Hi: 0x10855, Stride: 0x1},
+		unicode.Range32{Lo: 0x10860, Hi: 0x10876, Stride: 0x1},
+		unicode.Range32{Lo: 0x10880, Hi: 0x1089e, Stride: 0x1},
+		unicode.Range32{Lo: 0x108e0, Hi: 0x108f2, Stride: 0x1},
+		unicode.Range32{Lo: 0x108f4, Hi: 0x108f5, Stride: 0x1},
+		unicode.Range32{Lo: 0x10900, Hi: 0x10915, Stride: 0x1},
+		unicode.Range32{Lo: 0x10920, Hi: 0x10939, Stride: 0x1},
+		unicode.Range32{Lo: 0x10980, Hi: 0x109b7, Stride: 0x1},
+		unicode.Range32{Lo: 0x109be, Hi: 0x109bf, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a00, Hi: 0x10a00, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a10, Hi: 0x10a13, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a15, Hi: 0x10a17, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a19, Hi: 0x10a33, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a60, Hi: 0x10a7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x10a80, Hi: 0x10a9c, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ac0, Hi: 0x10ac7, Stride: 0x1},
+		unicode.Range32{Lo: 0x10ac9, Hi: 0x10ae4, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b00, Hi: 0x10b35, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b40, Hi: 0x10b55, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b60, Hi: 0x10b72, Stride: 0x1},
+		unicode.Range32{Lo: 0x10b80, Hi: 0x10b91, Stride: 0x1},
+		unicode.Range32{Lo: 0x10c00, Hi: 0x10c48, Stride: 0x1},
+		unicode.Range32{Lo: 0x11003, Hi: 0x11037, Stride: 0x1},
+		unicode.Range32{Lo: 0x11083, Hi: 0x110af, Stride: 0x1},
+		unicode.Range32{Lo: 0x110d0, Hi: 0x110e8, Stride: 0x1},
+		unicode.Range32{Lo: 0x11103, Hi: 0x11126, Stride: 0x1},
+		unicode.Range32{Lo: 0x11150, Hi: 0x11172, Stride: 0x1},
+		unicode.Range32{Lo: 0x11176, Hi: 0x11176, Stride: 0x1},
+		unicode.Range32{Lo: 0x11183, Hi: 0x111b2, Stride: 0x1},
+		unicode.Range32{Lo: 0x111c1, Hi: 0x111c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x111da, Hi: 0x111da, Stride: 0x1},
+		unicode.Range32{Lo: 0x111dc, Hi: 0x111dc, Stride: 0x1},
+		unicode.Range32{Lo: 0x11200, Hi: 0x11211, Stride: 0x1},
+		unicode.Range32{Lo: 0x11213, Hi: 0x1122b, Stride: 0x1},
+		unicode.Range32{Lo: 0x11280, Hi: 0x11286, Stride: 0x1},
+		unicode.Range32{Lo: 0x11288, Hi: 0x11288, Stride: 0x1},
+		unicode.Range32{Lo: 0x1128a, Hi: 0x1128d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1128f, Hi: 0x1129d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1129f, Hi: 0x112a8, Stride: 0x1},
+		unicode.Range32{Lo: 0x112b0, Hi: 0x112de, Stride: 0x1},
+		unicode.Range32{Lo: 0x11305, Hi: 0x1130c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1130f, Hi: 0x11310, Stride: 0x1},
+		unicode.Range32{Lo: 0x11313, Hi: 0x11328, Stride: 0x1},
+		unicode.Range32{Lo: 0x1132a, Hi: 0x11330, Stride: 0x1},
+		unicode.Range32{Lo: 0x11332, Hi: 0x11333, Stride: 0x1},
+		unicode.Range32{Lo: 0x11335, Hi: 0x11339, Stride: 0x1},
+		unicode.Range32{Lo: 0x1133d, Hi: 0x1133d, Stride: 0x1},
+		unicode.Range32{Lo: 0x11350, Hi: 0x11350, Stride: 0x1},
+		unicode.Range32{Lo: 0x1135d, Hi: 0x11361, Stride: 0x1},
+		unicode.Range32{Lo: 0x11400, Hi: 0x11434, Stride: 0x1},
+		unicode.Range32{Lo: 0x11447, Hi: 0x1144a, Stride: 0x1},
+		unicode.Range32{Lo: 0x11480, Hi: 0x114af, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c4, Hi: 0x114c5, Stride: 0x1},
+		unicode.Range32{Lo: 0x114c7, Hi: 0x114c7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11580, Hi: 0x115ae, Stride: 0x1},
+		unicode.Range32{Lo: 0x115d8, Hi: 0x115db, Stride: 0x1},
+		unicode.Range32{Lo: 0x11600, Hi: 0x1162f, Stride: 0x1},
+		unicode.Range32{Lo: 0x11644, Hi: 0x11644, Stride: 0x1},
+		unicode.Range32{Lo: 0x11680, Hi: 0x116aa, Stride: 0x1},
+		unicode.Range32{Lo: 0x11700, Hi: 0x11719, Stride: 0x1},
+		unicode.Range32{Lo: 0x118ff, Hi: 0x118ff, Stride: 0x1},
+		unicode.Range32{Lo: 0x11ac0, Hi: 0x11af8, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c00, Hi: 0x11c08, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c0a, Hi: 0x11c2e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c40, Hi: 0x11c40, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c72, Hi: 0x11c8f, Stride: 0x1},
+		unicode.Range32{Lo: 0x12000, Hi: 0x12399, Stride: 0x1},
+		unicode.Range32{Lo: 0x12400, Hi: 0x1246e, Stride: 0x1},
+		unicode.Range32{Lo: 0x12480, Hi: 0x12543, Stride: 0x1},
+		unicode.Range32{Lo: 0x13000, Hi: 0x1342e, Stride: 0x1},
+		unicode.Range32{Lo: 0x14400, Hi: 0x14646, Stride: 0x1},
+		unicode.Range32{Lo: 0x16800, Hi: 0x16a38, Stride: 0x1},
+		unicode.Range32{Lo: 0x16a40, Hi: 0x16a5e, Stride: 0x1},
+		unicode.Range32{Lo: 0x16ad0, Hi: 0x16aed, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b00, Hi: 0x16b2f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b40, Hi: 0x16b43, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b63, Hi: 0x16b77, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b7d, Hi: 0x16b8f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f00, Hi: 0x16f44, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f50, Hi: 0x16f50, Stride: 0x1},
+		unicode.Range32{Lo: 0x16f93, Hi: 0x16f9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16fe0, Hi: 0x16fe0, Stride: 0x1},
+		unicode.Range32{Lo: 0x17000, Hi: 0x187ec, Stride: 0x1},
+		unicode.Range32{Lo: 0x18800, Hi: 0x18af2, Stride: 0x1},
+		unicode.Range32{Lo: 0x1b000, Hi: 0x1b001, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc00, Hi: 0x1bc6a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc70, Hi: 0x1bc7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc80, Hi: 0x1bc88, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc90, Hi: 0x1bc99, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e800, Hi: 0x1e8c4, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee00, Hi: 0x1ee03, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee05, Hi: 0x1ee1f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee21, Hi: 0x1ee22, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee24, Hi: 0x1ee24, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee27, Hi: 0x1ee27, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee29, Hi: 0x1ee32, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee34, Hi: 0x1ee37, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee39, Hi: 0x1ee39, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee3b, Hi: 0x1ee3b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee42, Hi: 0x1ee42, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee47, Hi: 0x1ee47, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee49, Hi: 0x1ee49, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee4b, Hi: 0x1ee4b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee4d, Hi: 0x1ee4f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee51, Hi: 0x1ee52, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee54, Hi: 0x1ee54, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee57, Hi: 0x1ee57, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee59, Hi: 0x1ee59, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5b, Hi: 0x1ee5b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5d, Hi: 0x1ee5d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee5f, Hi: 0x1ee5f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee61, Hi: 0x1ee62, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee64, Hi: 0x1ee64, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee67, Hi: 0x1ee6a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee6c, Hi: 0x1ee72, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee74, Hi: 0x1ee77, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee79, Hi: 0x1ee7c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee7e, Hi: 0x1ee7e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee80, Hi: 0x1ee89, Stride: 0x1},
+		unicode.Range32{Lo: 0x1ee8b, Hi: 0x1ee9b, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eea1, Hi: 0x1eea3, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eea5, Hi: 0x1eea9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1eeab, Hi: 0x1eebb, Stride: 0x1},
+		unicode.Range32{Lo: 0x20000, Hi: 0x2a6d6, Stride: 0x1},
+		unicode.Range32{Lo: 0x2a700, Hi: 0x2b734, Stride: 0x1},
+		unicode.Range32{Lo: 0x2b740, Hi: 0x2b81d, Stride: 0x1},
+		unicode.Range32{Lo: 0x2b820, Hi: 0x2cea1, Stride: 0x1},
+		unicode.Range32{Lo: 0x2f800, Hi: 0x2fa1d, Stride: 0x1},
+	},
+	LatinOffset: 0,
+}
+
+var _SentenceSContinue = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x2c, Hi: 0x2c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2d, Hi: 0x2d, Stride: 0x1},
+		unicode.Range16{Lo: 0x3a, Hi: 0x3a, Stride: 0x1},
+		unicode.Range16{Lo: 0x55d, Hi: 0x55d, Stride: 0x1},
+		unicode.Range16{Lo: 0x60c, Hi: 0x60d, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f8, Hi: 0x7f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1802, Hi: 0x1802, Stride: 0x1},
+		unicode.Range16{Lo: 0x1808, Hi: 0x1808, Stride: 0x1},
+		unicode.Range16{Lo: 0x2013, Hi: 0x2014, Stride: 0x1},
+		unicode.Range16{Lo: 0x3001, Hi: 0x3001, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe10, Hi: 0xfe11, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe13, Hi: 0xfe13, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe31, Hi: 0xfe32, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe50, Hi: 0xfe51, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe55, Hi: 0xfe55, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe58, Hi: 0xfe58, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe63, Hi: 0xfe63, Stride: 0x1},
+		unicode.Range16{Lo: 0xff0c, Hi: 0xff0c, Stride: 0x1},
+		unicode.Range16{Lo: 0xff0d, Hi: 0xff0d, Stride: 0x1},
+		unicode.Range16{Lo: 0xff1a, Hi: 0xff1a, Stride: 0x1},
+		unicode.Range16{Lo: 0xff64, Hi: 0xff64, Stride: 0x1},
+	},
+	LatinOffset: 3,
+}
+
+var _SentenceSTerm = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x21, Hi: 0x21, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f, Hi: 0x3f, Stride: 0x1},
+		unicode.Range16{Lo: 0x589, Hi: 0x589, Stride: 0x1},
+		unicode.Range16{Lo: 0x61f, Hi: 0x61f, Stride: 0x1},
+		unicode.Range16{Lo: 0x6d4, Hi: 0x6d4, Stride: 0x1},
+		unicode.Range16{Lo: 0x700, Hi: 0x702, Stride: 0x1},
+		unicode.Range16{Lo: 0x7f9, Hi: 0x7f9, Stride: 0x1},
+		unicode.Range16{Lo: 0x964, Hi: 0x965, Stride: 0x1},
+		unicode.Range16{Lo: 0x104a, Hi: 0x104b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1362, Hi: 0x1362, Stride: 0x1},
+		unicode.Range16{Lo: 0x1367, Hi: 0x1368, Stride: 0x1},
+		unicode.Range16{Lo: 0x166e, Hi: 0x166e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1735, Hi: 0x1736, Stride: 0x1},
+		unicode.Range16{Lo: 0x1803, Hi: 0x1803, Stride: 0x1},
+		unicode.Range16{Lo: 0x1809, Hi: 0x1809, Stride: 0x1},
+		unicode.Range16{Lo: 0x1944, Hi: 0x1945, Stride: 0x1},
+		unicode.Range16{Lo: 0x1aa8, Hi: 0x1aab, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b5a, Hi: 0x1b5b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b5e, Hi: 0x1b5f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c3b, Hi: 0x1c3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c7e, Hi: 0x1c7f, Stride: 0x1},
+		unicode.Range16{Lo: 0x203c, Hi: 0x203d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2047, Hi: 0x2049, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e2e, Hi: 0x2e2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2e3c, Hi: 0x2e3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x3002, Hi: 0x3002, Stride: 0x1},
+		unicode.Range16{Lo: 0xa4ff, Hi: 0xa4ff, Stride: 0x1},
+		unicode.Range16{Lo: 0xa60e, Hi: 0xa60f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6f3, Hi: 0xa6f3, Stride: 0x1},
+		unicode.Range16{Lo: 0xa6f7, Hi: 0xa6f7, Stride: 0x1},
+		unicode.Range16{Lo: 0xa876, Hi: 0xa877, Stride: 0x1},
+		unicode.Range16{Lo: 0xa8ce, Hi: 0xa8cf, Stride: 0x1},
+		unicode.Range16{Lo: 0xa92f, Hi: 0xa92f, Stride: 0x1},
+		unicode.Range16{Lo: 0xa9c8, Hi: 0xa9c9, Stride: 0x1},
+		unicode.Range16{Lo: 0xaa5d, Hi: 0xaa5f, Stride: 0x1},
+		unicode.Range16{Lo: 0xaaf0, Hi: 0xaaf1, Stride: 0x1},
+		unicode.Range16{Lo: 0xabeb, Hi: 0xabeb, Stride: 0x1},
+		unicode.Range16{Lo: 0xfe56, Hi: 0xfe57, Stride: 0x1},
+		unicode.Range16{Lo: 0xff01, Hi: 0xff01, Stride: 0x1},
+		unicode.Range16{Lo: 0xff1f, Hi: 0xff1f, Stride: 0x1},
+		unicode.Range16{Lo: 0xff61, Hi: 0xff61, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x10a56, Hi: 0x10a57, Stride: 0x1},
+		unicode.Range32{Lo: 0x11047, Hi: 0x11048, Stride: 0x1},
+		unicode.Range32{Lo: 0x110be, Hi: 0x110c1, Stride: 0x1},
+		unicode.Range32{Lo: 0x11141, Hi: 0x11143, Stride: 0x1},
+		unicode.Range32{Lo: 0x111c5, Hi: 0x111c6, Stride: 0x1},
+		unicode.Range32{Lo: 0x111cd, Hi: 0x111cd, Stride: 0x1},
+		unicode.Range32{Lo: 0x111de, Hi: 0x111df, Stride: 0x1},
+		unicode.Range32{Lo: 0x11238, Hi: 0x11239, Stride: 0x1},
+		unicode.Range32{Lo: 0x1123b, Hi: 0x1123c, Stride: 0x1},
+		unicode.Range32{Lo: 0x112a9, Hi: 0x112a9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1144b, Hi: 0x1144c, Stride: 0x1},
+		unicode.Range32{Lo: 0x115c2, Hi: 0x115c3, Stride: 0x1},
+		unicode.Range32{Lo: 0x115c9, Hi: 0x115d7, Stride: 0x1},
+		unicode.Range32{Lo: 0x11641, Hi: 0x11642, Stride: 0x1},
+		unicode.Range32{Lo: 0x1173c, Hi: 0x1173e, Stride: 0x1},
+		unicode.Range32{Lo: 0x11c41, Hi: 0x11c42, Stride: 0x1},
+		unicode.Range32{Lo: 0x16a6e, Hi: 0x16a6f, Stride: 0x1},
+		unicode.Range32{Lo: 0x16af5, Hi: 0x16af5, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b37, Hi: 0x16b38, Stride: 0x1},
+		unicode.Range32{Lo: 0x16b44, Hi: 0x16b44, Stride: 0x1},
+		unicode.Range32{Lo: 0x1bc9f, Hi: 0x1bc9f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1da88, Hi: 0x1da88, Stride: 0x1},
+	},
+	LatinOffset: 2,
+}
+
+var _SentenceSep = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x85, Hi: 0x85, Stride: 0x1},
+		unicode.Range16{Lo: 0x2028, Hi: 0x2028, Stride: 0x1},
+		unicode.Range16{Lo: 0x2029, Hi: 0x2029, Stride: 0x1},
+	},
+	LatinOffset: 1,
+}
+
+var _SentenceSp = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x9, Hi: 0x9, Stride: 0x1},
+		unicode.Range16{Lo: 0xb, Hi: 0xc, Stride: 0x1},
+		unicode.Range16{Lo: 0x20, Hi: 0x20, Stride: 0x1},
+		unicode.Range16{Lo: 0xa0, Hi: 0xa0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1680, Hi: 0x1680, Stride: 0x1},
+		unicode.Range16{Lo: 0x2000, Hi: 0x200a, Stride: 0x1},
+		unicode.Range16{Lo: 0x202f, Hi: 0x202f, Stride: 0x1},
+		unicode.Range16{Lo: 0x205f, Hi: 0x205f, Stride: 0x1},
+		unicode.Range16{Lo: 0x3000, Hi: 0x3000, Stride: 0x1},
+	},
+	LatinOffset: 4,
+}
+
+var _SentenceUpper = &unicode.RangeTable{
+	R16: []unicode.Range16{
+		unicode.Range16{Lo: 0x41, Hi: 0x5a, Stride: 0x1},
+		unicode.Range16{Lo: 0xc0, Hi: 0xd6, Stride: 0x1},
+		unicode.Range16{Lo: 0xd8, Hi: 0xde, Stride: 0x1},
+		unicode.Range16{Lo: 0x100, Hi: 0x100, Stride: 0x1},
+		unicode.Range16{Lo: 0x102, Hi: 0x102, Stride: 0x1},
+		unicode.Range16{Lo: 0x104, Hi: 0x104, Stride: 0x1},
+		unicode.Range16{Lo: 0x106, Hi: 0x106, Stride: 0x1},
+		unicode.Range16{Lo: 0x108, Hi: 0x108, Stride: 0x1},
+		unicode.Range16{Lo: 0x10a, Hi: 0x10a, Stride: 0x1},
+		unicode.Range16{Lo: 0x10c, Hi: 0x10c, Stride: 0x1},
+		unicode.Range16{Lo: 0x10e, Hi: 0x10e, Stride: 0x1},
+		unicode.Range16{Lo: 0x110, Hi: 0x110, Stride: 0x1},
+		unicode.Range16{Lo: 0x112, Hi: 0x112, Stride: 0x1},
+		unicode.Range16{Lo: 0x114, Hi: 0x114, Stride: 0x1},
+		unicode.Range16{Lo: 0x116, Hi: 0x116, Stride: 0x1},
+		unicode.Range16{Lo: 0x118, Hi: 0x118, Stride: 0x1},
+		unicode.Range16{Lo: 0x11a, Hi: 0x11a, Stride: 0x1},
+		unicode.Range16{Lo: 0x11c, Hi: 0x11c, Stride: 0x1},
+		unicode.Range16{Lo: 0x11e, Hi: 0x11e, Stride: 0x1},
+		unicode.Range16{Lo: 0x120, Hi: 0x120, Stride: 0x1},
+		unicode.Range16{Lo: 0x122, Hi: 0x122, Stride: 0x1},
+		unicode.Range16{Lo: 0x124, Hi: 0x124, Stride: 0x1},
+		unicode.Range16{Lo: 0x126, Hi: 0x126, Stride: 0x1},
+		unicode.Range16{Lo: 0x128, Hi: 0x128, Stride: 0x1},
+		unicode.Range16{Lo: 0x12a, Hi: 0x12a, Stride: 0x1},
+		unicode.Range16{Lo: 0x12c, Hi: 0x12c, Stride: 0x1},
+		unicode.Range16{Lo: 0x12e, Hi: 0x12e, Stride: 0x1},
+		unicode.Range16{Lo: 0x130, Hi: 0x130, Stride: 0x1},
+		unicode.Range16{Lo: 0x132, Hi: 0x132, Stride: 0x1},
+		unicode.Range16{Lo: 0x134, Hi: 0x134, Stride: 0x1},
+		unicode.Range16{Lo: 0x136, Hi: 0x136, Stride: 0x1},
+		unicode.Range16{Lo: 0x139, Hi: 0x139, Stride: 0x1},
+		unicode.Range16{Lo: 0x13b, Hi: 0x13b, Stride: 0x1},
+		unicode.Range16{Lo: 0x13d, Hi: 0x13d, Stride: 0x1},
+		unicode.Range16{Lo: 0x13f, Hi: 0x13f, Stride: 0x1},
+		unicode.Range16{Lo: 0x141, Hi: 0x141, Stride: 0x1},
+		unicode.Range16{Lo: 0x143, Hi: 0x143, Stride: 0x1},
+		unicode.Range16{Lo: 0x145, Hi: 0x145, Stride: 0x1},
+		unicode.Range16{Lo: 0x147, Hi: 0x147, Stride: 0x1},
+		unicode.Range16{Lo: 0x14a, Hi: 0x14a, Stride: 0x1},
+		unicode.Range16{Lo: 0x14c, Hi: 0x14c, Stride: 0x1},
+		unicode.Range16{Lo: 0x14e, Hi: 0x14e, Stride: 0x1},
+		unicode.Range16{Lo: 0x150, Hi: 0x150, Stride: 0x1},
+		unicode.Range16{Lo: 0x152, Hi: 0x152, Stride: 0x1},
+		unicode.Range16{Lo: 0x154, Hi: 0x154, Stride: 0x1},
+		unicode.Range16{Lo: 0x156, Hi: 0x156, Stride: 0x1},
+		unicode.Range16{Lo: 0x158, Hi: 0x158, Stride: 0x1},
+		unicode.Range16{Lo: 0x15a, Hi: 0x15a, Stride: 0x1},
+		unicode.Range16{Lo: 0x15c, Hi: 0x15c, Stride: 0x1},
+		unicode.Range16{Lo: 0x15e, Hi: 0x15e, Stride: 0x1},
+		unicode.Range16{Lo: 0x160, Hi: 0x160, Stride: 0x1},
+		unicode.Range16{Lo: 0x162, Hi: 0x162, Stride: 0x1},
+		unicode.Range16{Lo: 0x164, Hi: 0x164, Stride: 0x1},
+		unicode.Range16{Lo: 0x166, Hi: 0x166, Stride: 0x1},
+		unicode.Range16{Lo: 0x168, Hi: 0x168, Stride: 0x1},
+		unicode.Range16{Lo: 0x16a, Hi: 0x16a, Stride: 0x1},
+		unicode.Range16{Lo: 0x16c, Hi: 0x16c, Stride: 0x1},
+		unicode.Range16{Lo: 0x16e, Hi: 0x16e, Stride: 0x1},
+		unicode.Range16{Lo: 0x170, Hi: 0x170, Stride: 0x1},
+		unicode.Range16{Lo: 0x172, Hi: 0x172, Stride: 0x1},
+		unicode.Range16{Lo: 0x174, Hi: 0x174, Stride: 0x1},
+		unicode.Range16{Lo: 0x176, Hi: 0x176, Stride: 0x1},
+		unicode.Range16{Lo: 0x178, Hi: 0x179, Stride: 0x1},
+		unicode.Range16{Lo: 0x17b, Hi: 0x17b, Stride: 0x1},
+		unicode.Range16{Lo: 0x17d, Hi: 0x17d, Stride: 0x1},
+		unicode.Range16{Lo: 0x181, Hi: 0x182, Stride: 0x1},
+		unicode.Range16{Lo: 0x184, Hi: 0x184, Stride: 0x1},
+		unicode.Range16{Lo: 0x186, Hi: 0x187, Stride: 0x1},
+		unicode.Range16{Lo: 0x189, Hi: 0x18b, Stride: 0x1},
+		unicode.Range16{Lo: 0x18e, Hi: 0x191, Stride: 0x1},
+		unicode.Range16{Lo: 0x193, Hi: 0x194, Stride: 0x1},
+		unicode.Range16{Lo: 0x196, Hi: 0x198, Stride: 0x1},
+		unicode.Range16{Lo: 0x19c, Hi: 0x19d, Stride: 0x1},
+		unicode.Range16{Lo: 0x19f, Hi: 0x1a0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a2, Hi: 0x1a2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a4, Hi: 0x1a4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a6, Hi: 0x1a7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1a9, Hi: 0x1a9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ac, Hi: 0x1ac, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ae, Hi: 0x1af, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b1, Hi: 0x1b3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b5, Hi: 0x1b5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1b7, Hi: 0x1b8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1bc, Hi: 0x1bc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c4, Hi: 0x1c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1c7, Hi: 0x1c8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ca, Hi: 0x1cb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cd, Hi: 0x1cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x1cf, Hi: 0x1cf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d1, Hi: 0x1d1, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d3, Hi: 0x1d3, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d5, Hi: 0x1d5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d7, Hi: 0x1d7, Stride: 0x1},
+		unicode.Range16{Lo: 0x1d9, Hi: 0x1d9, Stride: 0x1},
+		unicode.Range16{Lo: 0x1db, Hi: 0x1db, Stride: 0x1},
+		unicode.Range16{Lo: 0x1de, Hi: 0x1de, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0, Hi: 0x1e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2, Hi: 0x1e2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4, Hi: 0x1e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6, Hi: 0x1e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8, Hi: 0x1e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea, Hi: 0x1ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec, Hi: 0x1ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee, Hi: 0x1ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f1, Hi: 0x1f2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f4, Hi: 0x1f4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f6, Hi: 0x1f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fa, Hi: 0x1fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc, Hi: 0x1fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fe, Hi: 0x1fe, Stride: 0x1},
+		unicode.Range16{Lo: 0x200, Hi: 0x200, Stride: 0x1},
+		unicode.Range16{Lo: 0x202, Hi: 0x202, Stride: 0x1},
+		unicode.Range16{Lo: 0x204, Hi: 0x204, Stride: 0x1},
+		unicode.Range16{Lo: 0x206, Hi: 0x206, Stride: 0x1},
+		unicode.Range16{Lo: 0x208, Hi: 0x208, Stride: 0x1},
+		unicode.Range16{Lo: 0x20a, Hi: 0x20a, Stride: 0x1},
+		unicode.Range16{Lo: 0x20c, Hi: 0x20c, Stride: 0x1},
+		unicode.Range16{Lo: 0x20e, Hi: 0x20e, Stride: 0x1},
+		unicode.Range16{Lo: 0x210, Hi: 0x210, Stride: 0x1},
+		unicode.Range16{Lo: 0x212, Hi: 0x212, Stride: 0x1},
+		unicode.Range16{Lo: 0x214, Hi: 0x214, Stride: 0x1},
+		unicode.Range16{Lo: 0x216, Hi: 0x216, Stride: 0x1},
+		unicode.Range16{Lo: 0x218, Hi: 0x218, Stride: 0x1},
+		unicode.Range16{Lo: 0x21a, Hi: 0x21a, Stride: 0x1},
+		unicode.Range16{Lo: 0x21c, Hi: 0x21c, Stride: 0x1},
+		unicode.Range16{Lo: 0x21e, Hi: 0x21e, Stride: 0x1},
+		unicode.Range16{Lo: 0x220, Hi: 0x220, Stride: 0x1},
+		unicode.Range16{Lo: 0x222, Hi: 0x222, Stride: 0x1},
+		unicode.Range16{Lo: 0x224, Hi: 0x224, Stride: 0x1},
+		unicode.Range16{Lo: 0x226, Hi: 0x226, Stride: 0x1},
+		unicode.Range16{Lo: 0x228, Hi: 0x228, Stride: 0x1},
+		unicode.Range16{Lo: 0x22a, Hi: 0x22a, Stride: 0x1},
+		unicode.Range16{Lo: 0x22c, Hi: 0x22c, Stride: 0x1},
+		unicode.Range16{Lo: 0x22e, Hi: 0x22e, Stride: 0x1},
+		unicode.Range16{Lo: 0x230, Hi: 0x230, Stride: 0x1},
+		unicode.Range16{Lo: 0x232, Hi: 0x232, Stride: 0x1},
+		unicode.Range16{Lo: 0x23a, Hi: 0x23b, Stride: 0x1},
+		unicode.Range16{Lo: 0x23d, Hi: 0x23e, Stride: 0x1},
+		unicode.Range16{Lo: 0x241, Hi: 0x241, Stride: 0x1},
+		unicode.Range16{Lo: 0x243, Hi: 0x246, Stride: 0x1},
+		unicode.Range16{Lo: 0x248, Hi: 0x248, Stride: 0x1},
+		unicode.Range16{Lo: 0x24a, Hi: 0x24a, Stride: 0x1},
+		unicode.Range16{Lo: 0x24c, Hi: 0x24c, Stride: 0x1},
+		unicode.Range16{Lo: 0x24e, Hi: 0x24e, Stride: 0x1},
+		unicode.Range16{Lo: 0x370, Hi: 0x370, Stride: 0x1},
+		unicode.Range16{Lo: 0x372, Hi: 0x372, Stride: 0x1},
+		unicode.Range16{Lo: 0x376, Hi: 0x376, Stride: 0x1},
+		unicode.Range16{Lo: 0x37f, Hi: 0x37f, Stride: 0x1},
+		unicode.Range16{Lo: 0x386, Hi: 0x386, Stride: 0x1},
+		unicode.Range16{Lo: 0x388, Hi: 0x38a, Stride: 0x1},
+		unicode.Range16{Lo: 0x38c, Hi: 0x38c, Stride: 0x1},
+		unicode.Range16{Lo: 0x38e, Hi: 0x38f, Stride: 0x1},
+		unicode.Range16{Lo: 0x391, Hi: 0x3a1, Stride: 0x1},
+		unicode.Range16{Lo: 0x3a3, Hi: 0x3ab, Stride: 0x1},
+		unicode.Range16{Lo: 0x3cf, Hi: 0x3cf, Stride: 0x1},
+		unicode.Range16{Lo: 0x3d2, Hi: 0x3d4, Stride: 0x1},
+		unicode.Range16{Lo: 0x3d8, Hi: 0x3d8, Stride: 0x1},
+		unicode.Range16{Lo: 0x3da, Hi: 0x3da, Stride: 0x1},
+		unicode.Range16{Lo: 0x3dc, Hi: 0x3dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x3de, Hi: 0x3de, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e0, Hi: 0x3e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e2, Hi: 0x3e2, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e4, Hi: 0x3e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e6, Hi: 0x3e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x3e8, Hi: 0x3e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ea, Hi: 0x3ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ec, Hi: 0x3ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x3ee, Hi: 0x3ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f4, Hi: 0x3f4, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f7, Hi: 0x3f7, Stride: 0x1},
+		unicode.Range16{Lo: 0x3f9, Hi: 0x3fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x3fd, Hi: 0x42f, Stride: 0x1},
+		unicode.Range16{Lo: 0x460, Hi: 0x460, Stride: 0x1},
+		unicode.Range16{Lo: 0x462, Hi: 0x462, Stride: 0x1},
+		unicode.Range16{Lo: 0x464, Hi: 0x464, Stride: 0x1},
+		unicode.Range16{Lo: 0x466, Hi: 0x466, Stride: 0x1},
+		unicode.Range16{Lo: 0x468, Hi: 0x468, Stride: 0x1},
+		unicode.Range16{Lo: 0x46a, Hi: 0x46a, Stride: 0x1},
+		unicode.Range16{Lo: 0x46c, Hi: 0x46c, Stride: 0x1},
+		unicode.Range16{Lo: 0x46e, Hi: 0x46e, Stride: 0x1},
+		unicode.Range16{Lo: 0x470, Hi: 0x470, Stride: 0x1},
+		unicode.Range16{Lo: 0x472, Hi: 0x472, Stride: 0x1},
+		unicode.Range16{Lo: 0x474, Hi: 0x474, Stride: 0x1},
+		unicode.Range16{Lo: 0x476, Hi: 0x476, Stride: 0x1},
+		unicode.Range16{Lo: 0x478, Hi: 0x478, Stride: 0x1},
+		unicode.Range16{Lo: 0x47a, Hi: 0x47a, Stride: 0x1},
+		unicode.Range16{Lo: 0x47c, Hi: 0x47c, Stride: 0x1},
+		unicode.Range16{Lo: 0x47e, Hi: 0x47e, Stride: 0x1},
+		unicode.Range16{Lo: 0x480, Hi: 0x480, Stride: 0x1},
+		unicode.Range16{Lo: 0x48a, Hi: 0x48a, Stride: 0x1},
+		unicode.Range16{Lo: 0x48c, Hi: 0x48c, Stride: 0x1},
+		unicode.Range16{Lo: 0x48e, Hi: 0x48e, Stride: 0x1},
+		unicode.Range16{Lo: 0x490, Hi: 0x490, Stride: 0x1},
+		unicode.Range16{Lo: 0x492, Hi: 0x492, Stride: 0x1},
+		unicode.Range16{Lo: 0x494, Hi: 0x494, Stride: 0x1},
+		unicode.Range16{Lo: 0x496, Hi: 0x496, Stride: 0x1},
+		unicode.Range16{Lo: 0x498, Hi: 0x498, Stride: 0x1},
+		unicode.Range16{Lo: 0x49a, Hi: 0x49a, Stride: 0x1},
+		unicode.Range16{Lo: 0x49c, Hi: 0x49c, Stride: 0x1},
+		unicode.Range16{Lo: 0x49e, Hi: 0x49e, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a0, Hi: 0x4a0, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a2, Hi: 0x4a2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a4, Hi: 0x4a4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a6, Hi: 0x4a6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4a8, Hi: 0x4a8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4aa, Hi: 0x4aa, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ac, Hi: 0x4ac, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ae, Hi: 0x4ae, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b0, Hi: 0x4b0, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b2, Hi: 0x4b2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b4, Hi: 0x4b4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b6, Hi: 0x4b6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4b8, Hi: 0x4b8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ba, Hi: 0x4ba, Stride: 0x1},
+		unicode.Range16{Lo: 0x4bc, Hi: 0x4bc, Stride: 0x1},
+		unicode.Range16{Lo: 0x4be, Hi: 0x4be, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c0, Hi: 0x4c1, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c3, Hi: 0x4c3, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c5, Hi: 0x4c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c7, Hi: 0x4c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x4c9, Hi: 0x4c9, Stride: 0x1},
+		unicode.Range16{Lo: 0x4cb, Hi: 0x4cb, Stride: 0x1},
+		unicode.Range16{Lo: 0x4cd, Hi: 0x4cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d0, Hi: 0x4d0, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d2, Hi: 0x4d2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d4, Hi: 0x4d4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d6, Hi: 0x4d6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4d8, Hi: 0x4d8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4da, Hi: 0x4da, Stride: 0x1},
+		unicode.Range16{Lo: 0x4dc, Hi: 0x4dc, Stride: 0x1},
+		unicode.Range16{Lo: 0x4de, Hi: 0x4de, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e0, Hi: 0x4e0, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e2, Hi: 0x4e2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e4, Hi: 0x4e4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e6, Hi: 0x4e6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4e8, Hi: 0x4e8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ea, Hi: 0x4ea, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ec, Hi: 0x4ec, Stride: 0x1},
+		unicode.Range16{Lo: 0x4ee, Hi: 0x4ee, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f0, Hi: 0x4f0, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f2, Hi: 0x4f2, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f4, Hi: 0x4f4, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f6, Hi: 0x4f6, Stride: 0x1},
+		unicode.Range16{Lo: 0x4f8, Hi: 0x4f8, Stride: 0x1},
+		unicode.Range16{Lo: 0x4fa, Hi: 0x4fa, Stride: 0x1},
+		unicode.Range16{Lo: 0x4fc, Hi: 0x4fc, Stride: 0x1},
+		unicode.Range16{Lo: 0x4fe, Hi: 0x4fe, Stride: 0x1},
+		unicode.Range16{Lo: 0x500, Hi: 0x500, Stride: 0x1},
+		unicode.Range16{Lo: 0x502, Hi: 0x502, Stride: 0x1},
+		unicode.Range16{Lo: 0x504, Hi: 0x504, Stride: 0x1},
+		unicode.Range16{Lo: 0x506, Hi: 0x506, Stride: 0x1},
+		unicode.Range16{Lo: 0x508, Hi: 0x508, Stride: 0x1},
+		unicode.Range16{Lo: 0x50a, Hi: 0x50a, Stride: 0x1},
+		unicode.Range16{Lo: 0x50c, Hi: 0x50c, Stride: 0x1},
+		unicode.Range16{Lo: 0x50e, Hi: 0x50e, Stride: 0x1},
+		unicode.Range16{Lo: 0x510, Hi: 0x510, Stride: 0x1},
+		unicode.Range16{Lo: 0x512, Hi: 0x512, Stride: 0x1},
+		unicode.Range16{Lo: 0x514, Hi: 0x514, Stride: 0x1},
+		unicode.Range16{Lo: 0x516, Hi: 0x516, Stride: 0x1},
+		unicode.Range16{Lo: 0x518, Hi: 0x518, Stride: 0x1},
+		unicode.Range16{Lo: 0x51a, Hi: 0x51a, Stride: 0x1},
+		unicode.Range16{Lo: 0x51c, Hi: 0x51c, Stride: 0x1},
+		unicode.Range16{Lo: 0x51e, Hi: 0x51e, Stride: 0x1},
+		unicode.Range16{Lo: 0x520, Hi: 0x520, Stride: 0x1},
+		unicode.Range16{Lo: 0x522, Hi: 0x522, Stride: 0x1},
+		unicode.Range16{Lo: 0x524, Hi: 0x524, Stride: 0x1},
+		unicode.Range16{Lo: 0x526, Hi: 0x526, Stride: 0x1},
+		unicode.Range16{Lo: 0x528, Hi: 0x528, Stride: 0x1},
+		unicode.Range16{Lo: 0x52a, Hi: 0x52a, Stride: 0x1},
+		unicode.Range16{Lo: 0x52c, Hi: 0x52c, Stride: 0x1},
+		unicode.Range16{Lo: 0x52e, Hi: 0x52e, Stride: 0x1},
+		unicode.Range16{Lo: 0x531, Hi: 0x556, Stride: 0x1},
+		unicode.Range16{Lo: 0x10a0, Hi: 0x10c5, Stride: 0x1},
+		unicode.Range16{Lo: 0x10c7, Hi: 0x10c7, Stride: 0x1},
+		unicode.Range16{Lo: 0x10cd, Hi: 0x10cd, Stride: 0x1},
+		unicode.Range16{Lo: 0x13a0, Hi: 0x13f5, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e00, Hi: 0x1e00, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e02, Hi: 0x1e02, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e04, Hi: 0x1e04, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e06, Hi: 0x1e06, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e08, Hi: 0x1e08, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0a, Hi: 0x1e0a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0c, Hi: 0x1e0c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e0e, Hi: 0x1e0e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e10, Hi: 0x1e10, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e12, Hi: 0x1e12, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e14, Hi: 0x1e14, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e16, Hi: 0x1e16, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e18, Hi: 0x1e18, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1a, Hi: 0x1e1a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1c, Hi: 0x1e1c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e1e, Hi: 0x1e1e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e20, Hi: 0x1e20, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e22, Hi: 0x1e22, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e24, Hi: 0x1e24, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e26, Hi: 0x1e26, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e28, Hi: 0x1e28, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2a, Hi: 0x1e2a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2c, Hi: 0x1e2c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e2e, Hi: 0x1e2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e30, Hi: 0x1e30, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e32, Hi: 0x1e32, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e34, Hi: 0x1e34, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e36, Hi: 0x1e36, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e38, Hi: 0x1e38, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3a, Hi: 0x1e3a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3c, Hi: 0x1e3c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e3e, Hi: 0x1e3e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e40, Hi: 0x1e40, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e42, Hi: 0x1e42, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e44, Hi: 0x1e44, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e46, Hi: 0x1e46, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e48, Hi: 0x1e48, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4a, Hi: 0x1e4a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4c, Hi: 0x1e4c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e4e, Hi: 0x1e4e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e50, Hi: 0x1e50, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e52, Hi: 0x1e52, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e54, Hi: 0x1e54, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e56, Hi: 0x1e56, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e58, Hi: 0x1e58, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5a, Hi: 0x1e5a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5c, Hi: 0x1e5c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e5e, Hi: 0x1e5e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e60, Hi: 0x1e60, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e62, Hi: 0x1e62, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e64, Hi: 0x1e64, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e66, Hi: 0x1e66, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e68, Hi: 0x1e68, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6a, Hi: 0x1e6a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6c, Hi: 0x1e6c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e6e, Hi: 0x1e6e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e70, Hi: 0x1e70, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e72, Hi: 0x1e72, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e74, Hi: 0x1e74, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e76, Hi: 0x1e76, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e78, Hi: 0x1e78, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7a, Hi: 0x1e7a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7c, Hi: 0x1e7c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e7e, Hi: 0x1e7e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e80, Hi: 0x1e80, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e82, Hi: 0x1e82, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e84, Hi: 0x1e84, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e86, Hi: 0x1e86, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e88, Hi: 0x1e88, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8a, Hi: 0x1e8a, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8c, Hi: 0x1e8c, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e8e, Hi: 0x1e8e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e90, Hi: 0x1e90, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e92, Hi: 0x1e92, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e94, Hi: 0x1e94, Stride: 0x1},
+		unicode.Range16{Lo: 0x1e9e, Hi: 0x1e9e, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea0, Hi: 0x1ea0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea2, Hi: 0x1ea2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea4, Hi: 0x1ea4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea6, Hi: 0x1ea6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ea8, Hi: 0x1ea8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eaa, Hi: 0x1eaa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eac, Hi: 0x1eac, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eae, Hi: 0x1eae, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb0, Hi: 0x1eb0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb2, Hi: 0x1eb2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb4, Hi: 0x1eb4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb6, Hi: 0x1eb6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eb8, Hi: 0x1eb8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eba, Hi: 0x1eba, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ebc, Hi: 0x1ebc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ebe, Hi: 0x1ebe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec0, Hi: 0x1ec0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec2, Hi: 0x1ec2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec4, Hi: 0x1ec4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec6, Hi: 0x1ec6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ec8, Hi: 0x1ec8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eca, Hi: 0x1eca, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ecc, Hi: 0x1ecc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ece, Hi: 0x1ece, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed0, Hi: 0x1ed0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed2, Hi: 0x1ed2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed4, Hi: 0x1ed4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed6, Hi: 0x1ed6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ed8, Hi: 0x1ed8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eda, Hi: 0x1eda, Stride: 0x1},
+		unicode.Range16{Lo: 0x1edc, Hi: 0x1edc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ede, Hi: 0x1ede, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee0, Hi: 0x1ee0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee2, Hi: 0x1ee2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee4, Hi: 0x1ee4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee6, Hi: 0x1ee6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ee8, Hi: 0x1ee8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eea, Hi: 0x1eea, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eec, Hi: 0x1eec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1eee, Hi: 0x1eee, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef0, Hi: 0x1ef0, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef2, Hi: 0x1ef2, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef4, Hi: 0x1ef4, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef6, Hi: 0x1ef6, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ef8, Hi: 0x1ef8, Stride: 0x1},
+		unicode.Range16{Lo: 0x1efa, Hi: 0x1efa, Stride: 0x1},
+		unicode.Range16{Lo: 0x1efc, Hi: 0x1efc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1efe, Hi: 0x1efe, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f08, Hi: 0x1f0f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f18, Hi: 0x1f1d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f28, Hi: 0x1f2f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f38, Hi: 0x1f3f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f48, Hi: 0x1f4d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f59, Hi: 0x1f59, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5b, Hi: 0x1f5b, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5d, Hi: 0x1f5d, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f5f, Hi: 0x1f5f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f68, Hi: 0x1f6f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f88, Hi: 0x1f8f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1f98, Hi: 0x1f9f, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fa8, Hi: 0x1faf, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fb8, Hi: 0x1fbc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fc8, Hi: 0x1fcc, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fd8, Hi: 0x1fdb, Stride: 0x1},
+		unicode.Range16{Lo: 0x1fe8, Hi: 0x1fec, Stride: 0x1},
+		unicode.Range16{Lo: 0x1ff8, Hi: 0x1ffc, Stride: 0x1},
+		unicode.Range16{Lo: 0x2102, Hi: 0x2102, Stride: 0x1},
+		unicode.Range16{Lo: 0x2107, Hi: 0x2107, Stride: 0x1},
+		unicode.Range16{Lo: 0x210b, Hi: 0x210d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2110, Hi: 0x2112, Stride: 0x1},
+		unicode.Range16{Lo: 0x2115, Hi: 0x2115, Stride: 0x1},
+		unicode.Range16{Lo: 0x2119, Hi: 0x211d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2124, Hi: 0x2124, Stride: 0x1},
+		unicode.Range16{Lo: 0x2126, Hi: 0x2126, Stride: 0x1},
+		unicode.Range16{Lo: 0x2128, Hi: 0x2128, Stride: 0x1},
+		unicode.Range16{Lo: 0x212a, Hi: 0x212d, Stride: 0x1},
+		unicode.Range16{Lo: 0x2130, Hi: 0x2133, Stride: 0x1},
+		unicode.Range16{Lo: 0x213e, Hi: 0x213f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2145, Hi: 0x2145, Stride: 0x1},
+		unicode.Range16{Lo: 0x2160, Hi: 0x216f, Stride: 0x1},
+		unicode.Range16{Lo: 0x2183, Hi: 0x2183, Stride: 0x1},
+		unicode.Range16{Lo: 0x24b6, Hi: 0x24cf, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c00, Hi: 0x2c2e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c60, Hi: 0x2c60, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c62, Hi: 0x2c64, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c67, Hi: 0x2c67, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c69, Hi: 0x2c69, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6b, Hi: 0x2c6b, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c6d, Hi: 0x2c70, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c72, Hi: 0x2c72, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c75, Hi: 0x2c75, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c7e, Hi: 0x2c80, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c82, Hi: 0x2c82, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c84, Hi: 0x2c84, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c86, Hi: 0x2c86, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c88, Hi: 0x2c88, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8a, Hi: 0x2c8a, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8c, Hi: 0x2c8c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c8e, Hi: 0x2c8e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c90, Hi: 0x2c90, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c92, Hi: 0x2c92, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c94, Hi: 0x2c94, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c96, Hi: 0x2c96, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c98, Hi: 0x2c98, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9a, Hi: 0x2c9a, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9c, Hi: 0x2c9c, Stride: 0x1},
+		unicode.Range16{Lo: 0x2c9e, Hi: 0x2c9e, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca0, Hi: 0x2ca0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca2, Hi: 0x2ca2, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca4, Hi: 0x2ca4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca6, Hi: 0x2ca6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ca8, Hi: 0x2ca8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2caa, Hi: 0x2caa, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cac, Hi: 0x2cac, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cae, Hi: 0x2cae, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb0, Hi: 0x2cb0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb2, Hi: 0x2cb2, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb4, Hi: 0x2cb4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb6, Hi: 0x2cb6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cb8, Hi: 0x2cb8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cba, Hi: 0x2cba, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cbc, Hi: 0x2cbc, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cbe, Hi: 0x2cbe, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc0, Hi: 0x2cc0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc2, Hi: 0x2cc2, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc4, Hi: 0x2cc4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc6, Hi: 0x2cc6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cc8, Hi: 0x2cc8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cca, Hi: 0x2cca, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ccc, Hi: 0x2ccc, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cce, Hi: 0x2cce, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd0, Hi: 0x2cd0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd2, Hi: 0x2cd2, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd4, Hi: 0x2cd4, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd6, Hi: 0x2cd6, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cd8, Hi: 0x2cd8, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cda, Hi: 0x2cda, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cdc, Hi: 0x2cdc, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cde, Hi: 0x2cde, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ce0, Hi: 0x2ce0, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ce2, Hi: 0x2ce2, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ceb, Hi: 0x2ceb, Stride: 0x1},
+		unicode.Range16{Lo: 0x2ced, Hi: 0x2ced, Stride: 0x1},
+		unicode.Range16{Lo: 0x2cf2, Hi: 0x2cf2, Stride: 0x1},
+		unicode.Range16{Lo: 0xa640, Hi: 0xa640, Stride: 0x1},
+		unicode.Range16{Lo: 0xa642, Hi: 0xa642, Stride: 0x1},
+		unicode.Range16{Lo: 0xa644, Hi: 0xa644, Stride: 0x1},
+		unicode.Range16{Lo: 0xa646, Hi: 0xa646, Stride: 0x1},
+		unicode.Range16{Lo: 0xa648, Hi: 0xa648, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64a, Hi: 0xa64a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64c, Hi: 0xa64c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa64e, Hi: 0xa64e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa650, Hi: 0xa650, Stride: 0x1},
+		unicode.Range16{Lo: 0xa652, Hi: 0xa652, Stride: 0x1},
+		unicode.Range16{Lo: 0xa654, Hi: 0xa654, Stride: 0x1},
+		unicode.Range16{Lo: 0xa656, Hi: 0xa656, Stride: 0x1},
+		unicode.Range16{Lo: 0xa658, Hi: 0xa658, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65a, Hi: 0xa65a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65c, Hi: 0xa65c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa65e, Hi: 0xa65e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa660, Hi: 0xa660, Stride: 0x1},
+		unicode.Range16{Lo: 0xa662, Hi: 0xa662, Stride: 0x1},
+		unicode.Range16{Lo: 0xa664, Hi: 0xa664, Stride: 0x1},
+		unicode.Range16{Lo: 0xa666, Hi: 0xa666, Stride: 0x1},
+		unicode.Range16{Lo: 0xa668, Hi: 0xa668, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66a, Hi: 0xa66a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa66c, Hi: 0xa66c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa680, Hi: 0xa680, Stride: 0x1},
+		unicode.Range16{Lo: 0xa682, Hi: 0xa682, Stride: 0x1},
+		unicode.Range16{Lo: 0xa684, Hi: 0xa684, Stride: 0x1},
+		unicode.Range16{Lo: 0xa686, Hi: 0xa686, Stride: 0x1},
+		unicode.Range16{Lo: 0xa688, Hi: 0xa688, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68a, Hi: 0xa68a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68c, Hi: 0xa68c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa68e, Hi: 0xa68e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa690, Hi: 0xa690, Stride: 0x1},
+		unicode.Range16{Lo: 0xa692, Hi: 0xa692, Stride: 0x1},
+		unicode.Range16{Lo: 0xa694, Hi: 0xa694, Stride: 0x1},
+		unicode.Range16{Lo: 0xa696, Hi: 0xa696, Stride: 0x1},
+		unicode.Range16{Lo: 0xa698, Hi: 0xa698, Stride: 0x1},
+		unicode.Range16{Lo: 0xa69a, Hi: 0xa69a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa722, Hi: 0xa722, Stride: 0x1},
+		unicode.Range16{Lo: 0xa724, Hi: 0xa724, Stride: 0x1},
+		unicode.Range16{Lo: 0xa726, Hi: 0xa726, Stride: 0x1},
+		unicode.Range16{Lo: 0xa728, Hi: 0xa728, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72a, Hi: 0xa72a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72c, Hi: 0xa72c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa72e, Hi: 0xa72e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa732, Hi: 0xa732, Stride: 0x1},
+		unicode.Range16{Lo: 0xa734, Hi: 0xa734, Stride: 0x1},
+		unicode.Range16{Lo: 0xa736, Hi: 0xa736, Stride: 0x1},
+		unicode.Range16{Lo: 0xa738, Hi: 0xa738, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73a, Hi: 0xa73a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73c, Hi: 0xa73c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa73e, Hi: 0xa73e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa740, Hi: 0xa740, Stride: 0x1},
+		unicode.Range16{Lo: 0xa742, Hi: 0xa742, Stride: 0x1},
+		unicode.Range16{Lo: 0xa744, Hi: 0xa744, Stride: 0x1},
+		unicode.Range16{Lo: 0xa746, Hi: 0xa746, Stride: 0x1},
+		unicode.Range16{Lo: 0xa748, Hi: 0xa748, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74a, Hi: 0xa74a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74c, Hi: 0xa74c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa74e, Hi: 0xa74e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa750, Hi: 0xa750, Stride: 0x1},
+		unicode.Range16{Lo: 0xa752, Hi: 0xa752, Stride: 0x1},
+		unicode.Range16{Lo: 0xa754, Hi: 0xa754, Stride: 0x1},
+		unicode.Range16{Lo: 0xa756, Hi: 0xa756, Stride: 0x1},
+		unicode.Range16{Lo: 0xa758, Hi: 0xa758, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75a, Hi: 0xa75a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75c, Hi: 0xa75c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa75e, Hi: 0xa75e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa760, Hi: 0xa760, Stride: 0x1},
+		unicode.Range16{Lo: 0xa762, Hi: 0xa762, Stride: 0x1},
+		unicode.Range16{Lo: 0xa764, Hi: 0xa764, Stride: 0x1},
+		unicode.Range16{Lo: 0xa766, Hi: 0xa766, Stride: 0x1},
+		unicode.Range16{Lo: 0xa768, Hi: 0xa768, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76a, Hi: 0xa76a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76c, Hi: 0xa76c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa76e, Hi: 0xa76e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa779, Hi: 0xa779, Stride: 0x1},
+		unicode.Range16{Lo: 0xa77b, Hi: 0xa77b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa77d, Hi: 0xa77e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa780, Hi: 0xa780, Stride: 0x1},
+		unicode.Range16{Lo: 0xa782, Hi: 0xa782, Stride: 0x1},
+		unicode.Range16{Lo: 0xa784, Hi: 0xa784, Stride: 0x1},
+		unicode.Range16{Lo: 0xa786, Hi: 0xa786, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78b, Hi: 0xa78b, Stride: 0x1},
+		unicode.Range16{Lo: 0xa78d, Hi: 0xa78d, Stride: 0x1},
+		unicode.Range16{Lo: 0xa790, Hi: 0xa790, Stride: 0x1},
+		unicode.Range16{Lo: 0xa792, Hi: 0xa792, Stride: 0x1},
+		unicode.Range16{Lo: 0xa796, Hi: 0xa796, Stride: 0x1},
+		unicode.Range16{Lo: 0xa798, Hi: 0xa798, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79a, Hi: 0xa79a, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79c, Hi: 0xa79c, Stride: 0x1},
+		unicode.Range16{Lo: 0xa79e, Hi: 0xa79e, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a0, Hi: 0xa7a0, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a2, Hi: 0xa7a2, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a4, Hi: 0xa7a4, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a6, Hi: 0xa7a6, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7a8, Hi: 0xa7a8, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7aa, Hi: 0xa7ae, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7b0, Hi: 0xa7b4, Stride: 0x1},
+		unicode.Range16{Lo: 0xa7b6, Hi: 0xa7b6, Stride: 0x1},
+		unicode.Range16{Lo: 0xff21, Hi: 0xff3a, Stride: 0x1},
+	},
+	R32: []unicode.Range32{
+		unicode.Range32{Lo: 0x10400, Hi: 0x10427, Stride: 0x1},
+		unicode.Range32{Lo: 0x104b0, Hi: 0x104d3, Stride: 0x1},
+		unicode.Range32{Lo: 0x10c80, Hi: 0x10cb2, Stride: 0x1},
+		unicode.Range32{Lo: 0x118a0, Hi: 0x118bf, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d400, Hi: 0x1d419, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d434, Hi: 0x1d44d, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d468, Hi: 0x1d481, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d49c, Hi: 0x1d49c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d49e, Hi: 0x1d49f, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a2, Hi: 0x1d4a2, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a5, Hi: 0x1d4a6, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4a9, Hi: 0x1d4ac, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4ae, Hi: 0x1d4b5, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d4d0, Hi: 0x1d4e9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d504, Hi: 0x1d505, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d507, Hi: 0x1d50a, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d50d, Hi: 0x1d514, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d516, Hi: 0x1d51c, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d538, Hi: 0x1d539, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d53b, Hi: 0x1d53e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d540, Hi: 0x1d544, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d546, Hi: 0x1d546, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d54a, Hi: 0x1d550, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d56c, Hi: 0x1d585, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d5a0, Hi: 0x1d5b9, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d5d4, Hi: 0x1d5ed, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d608, Hi: 0x1d621, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d63c, Hi: 0x1d655, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d670, Hi: 0x1d689, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6a8, Hi: 0x1d6c0, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d6e2, Hi: 0x1d6fa, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d71c, Hi: 0x1d734, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d756, Hi: 0x1d76e, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d790, Hi: 0x1d7a8, Stride: 0x1},
+		unicode.Range32{Lo: 0x1d7ca, Hi: 0x1d7ca, Stride: 0x1},
+		unicode.Range32{Lo: 0x1e900, Hi: 0x1e921, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f130, Hi: 0x1f149, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f150, Hi: 0x1f169, Stride: 0x1},
+		unicode.Range32{Lo: 0x1f170, Hi: 0x1f189, Stride: 0x1},
+	},
+	LatinOffset: 3,
+}
+
+type _SentenceRuneRange unicode.RangeTable
+
+func _SentenceRuneType(r rune) *_SentenceRuneRange {
+	switch {
+	case unicode.Is(_SentenceATerm, r):
+		return (*_SentenceRuneRange)(_SentenceATerm)
+	case unicode.Is(_SentenceCR, r):
+		return (*_SentenceRuneRange)(_SentenceCR)
+	case unicode.Is(_SentenceClose, r):
+		return (*_SentenceRuneRange)(_SentenceClose)
+	case unicode.Is(_SentenceExtend, r):
+		return (*_SentenceRuneRange)(_SentenceExtend)
+	case unicode.Is(_SentenceFormat, r):
+		return (*_SentenceRuneRange)(_SentenceFormat)
+	case unicode.Is(_SentenceLF, r):
+		return (*_SentenceRuneRange)(_SentenceLF)
+	case unicode.Is(_SentenceLower, r):
+		return (*_SentenceRuneRange)(_SentenceLower)
+	case unicode.Is(_SentenceNumeric, r):
+		return (*_SentenceRuneRange)(_SentenceNumeric)
+	case unicode.Is(_SentenceOLetter, r):
+		return (*_SentenceRuneRange)(_SentenceOLetter)
+	case unicode.Is(_SentenceSContinue, r):
+		return (*_SentenceRuneRange)(_SentenceSContinue)
+	case unicode.Is(_SentenceSTerm, r):
+		return (*_SentenceRuneRange)(_SentenceSTerm)
+	case unicode.Is(_SentenceSep, r):
+		return (*_SentenceRuneRange)(_SentenceSep)
+	case unicode.Is(_SentenceSp, r):
+		return (*_SentenceRuneRange)(_SentenceSp)
+	case unicode.Is(_SentenceUpper, r):
+		return (*_SentenceRuneRange)(_SentenceUpper)
+	default:
+		return nil
+	}
+}
+func (rng *_SentenceRuneRange) String() string {
+	switch (*unicode.RangeTable)(rng) {
+	case _SentenceATerm:
+		return "ATerm"
+	case _SentenceCR:
+		return "CR"
+	case _SentenceClose:
+		return "Close"
+	case _SentenceExtend:
+		return "Extend"
+	case _SentenceFormat:
+		return "Format"
+	case _SentenceLF:
+		return "LF"
+	case _SentenceLower:
+		return "Lower"
+	case _SentenceNumeric:
+		return "Numeric"
+	case _SentenceOLetter:
+		return "OLetter"
+	case _SentenceSContinue:
+		return "SContinue"
+	case _SentenceSTerm:
+		return "STerm"
+	case _SentenceSep:
+		return "Sep"
+	case _SentenceSp:
+		return "Sp"
+	case _SentenceUpper:
+		return "Upper"
+	default:
+		return "Other"
+	}
+}
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/unicode2ragel.rb b/vendor/github.com/apparentlymart/go-textseg/textseg/unicode2ragel.rb
new file mode 100644
index 000000000..422e4e5cc
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/unicode2ragel.rb
@@ -0,0 +1,335 @@
+#!/usr/bin/env ruby
+#
+# This scripted has been updated to accept more command-line arguments:
+#
+#    -u, --url                        URL to process
+#    -m, --machine                    Machine name
+#    -p, --properties                 Properties to add to the machine
+#    -o, --output                     Write output to file
+#
+# Updated by: Marty Schoch <marty.schoch@gmail.com>
+# 
+# This script uses the unicode spec to generate a Ragel state machine
+# that recognizes unicode alphanumeric characters.  It generates 5
+# character classes: uupper, ulower, ualpha, udigit, and ualnum.
+# Currently supported encodings are UTF-8 [default] and UCS-4.
+#
+# Usage: unicode2ragel.rb [options]
+#    -e, --encoding [ucs4 | utf8]     Data encoding
+#    -h, --help                       Show this message
+#
+# This script was originally written as part of the Ferret search
+# engine library.
+#
+# Author: Rakan El-Khalil <rakan@well.com>
+
+require 'optparse'
+require 'open-uri'
+
+ENCODINGS = [ :utf8, :ucs4 ]
+ALPHTYPES = { :utf8 => "byte", :ucs4 => "rune" }
+DEFAULT_CHART_URL = "http://www.unicode.org/Public/5.1.0/ucd/DerivedCoreProperties.txt"
+DEFAULT_MACHINE_NAME= "WChar"
+
+###
+# Display vars & default option
+
+TOTAL_WIDTH = 80
+RANGE_WIDTH = 23
+@encoding = :utf8
+@chart_url = DEFAULT_CHART_URL
+machine_name = DEFAULT_MACHINE_NAME
+properties = []
+@output = $stdout
+
+###
+# Option parsing
+
+cli_opts = OptionParser.new do |opts|
+  opts.on("-e", "--encoding [ucs4 | utf8]", "Data encoding") do |o|
+    @encoding = o.downcase.to_sym
+  end
+  opts.on("-h", "--help", "Show this message") do
+    puts opts
+    exit
+  end
+  opts.on("-u", "--url URL", "URL to process") do |o|
+    @chart_url = o 
+  end
+  opts.on("-m", "--machine MACHINE_NAME", "Machine name") do |o|
+    machine_name = o
+  end
+  opts.on("-p", "--properties x,y,z", Array, "Properties to add to machine") do |o|
+    properties = o
+  end
+  opts.on("-o", "--output FILE", "output file") do |o|
+    @output = File.new(o, "w+")
+  end
+end
+
+cli_opts.parse(ARGV)
+unless ENCODINGS.member? @encoding
+  puts "Invalid encoding: #{@encoding}"
+  puts cli_opts
+  exit
+end
+
+##
+# Downloads the document at url and yields every alpha line's hex
+# range and description.
+
+def each_alpha( url, property ) 
+  open( url ) do |file|
+    file.each_line do |line|
+      next if line =~ /^#/;
+      next if line !~ /; #{property} #/;
+
+      range, description = line.split(/;/)
+      range.strip!
+      description.gsub!(/.*#/, '').strip!
+
+      if range =~ /\.\./
+           start, stop = range.split '..'
+      else start = stop = range
+      end
+
+      yield start.hex .. stop.hex, description
+    end
+  end
+end
+
+###
+# Formats to hex at minimum width
+
+def to_hex( n )
+  r = "%0X" % n
+  r = "0#{r}" unless (r.length % 2).zero?
+  r
+end
+
+###
+# UCS4 is just a straight hex conversion of the unicode codepoint.
+
+def to_ucs4( range )
+  rangestr  =   "0x" + to_hex(range.begin)
+  rangestr << "..0x" + to_hex(range.end) if range.begin != range.end
+  [ rangestr ]
+end
+
+##
+# 0x00     - 0x7f     -> 0zzzzzzz[7]
+# 0x80     - 0x7ff    -> 110yyyyy[5] 10zzzzzz[6]
+# 0x800    - 0xffff   -> 1110xxxx[4] 10yyyyyy[6] 10zzzzzz[6]
+# 0x010000 - 0x10ffff -> 11110www[3] 10xxxxxx[6] 10yyyyyy[6] 10zzzzzz[6] 
+
+UTF8_BOUNDARIES = [0x7f, 0x7ff, 0xffff, 0x10ffff]
+
+def to_utf8_enc( n )
+  r = 0
+  if n <= 0x7f
+    r = n
+  elsif n <= 0x7ff
+    y = 0xc0 | (n >> 6)
+    z = 0x80 | (n & 0x3f)
+    r = y << 8 | z
+  elsif n <= 0xffff
+    x = 0xe0 | (n >> 12)
+    y = 0x80 | (n >>  6) & 0x3f
+    z = 0x80 |  n        & 0x3f
+    r = x << 16 | y << 8 | z
+  elsif n <= 0x10ffff
+    w = 0xf0 | (n >> 18)
+    x = 0x80 | (n >> 12) & 0x3f
+    y = 0x80 | (n >>  6) & 0x3f
+    z = 0x80 |  n        & 0x3f
+    r = w << 24 | x << 16 | y << 8 | z
+  end
+
+  to_hex(r)
+end
+
+def from_utf8_enc( n )
+  n = n.hex
+  r = 0
+  if n <= 0x7f
+    r = n
+  elsif n <= 0xdfff
+    y = (n >> 8) & 0x1f
+    z =  n       & 0x3f
+    r = y << 6 | z
+  elsif n <= 0xefffff
+    x = (n >> 16) & 0x0f
+    y = (n >>  8) & 0x3f
+    z =  n        & 0x3f
+    r = x << 10 | y << 6 | z
+  elsif n <= 0xf7ffffff
+    w = (n >> 24) & 0x07
+    x = (n >> 16) & 0x3f
+    y = (n >>  8) & 0x3f
+    z =  n        & 0x3f
+    r = w << 18 | x << 12 | y << 6 | z
+  end
+  r
+end
+
+###
+# Given a range, splits it up into ranges that can be continuously
+# encoded into utf8.  Eg: 0x00 .. 0xff => [0x00..0x7f, 0x80..0xff]
+# This is not strictly needed since the current [5.1] unicode standard
+# doesn't have ranges that straddle utf8 boundaries.  This is included
+# for completeness as there is no telling if that will ever change.
+
+def utf8_ranges( range )
+  ranges = []
+  UTF8_BOUNDARIES.each do |max|
+    if range.begin <= max
+      if range.end <= max
+        ranges << range
+        return ranges
+      end
+
+      ranges << (range.begin .. max)
+      range = (max + 1) .. range.end
+    end
+  end
+  ranges
+end
+
+def build_range( start, stop )
+  size = start.size/2
+  left = size - 1
+  return [""] if size < 1
+
+  a = start[0..1]
+  b = stop[0..1]
+
+  ###
+  # Shared prefix
+
+  if a == b
+    return build_range(start[2..-1], stop[2..-1]).map do |elt|
+      "0x#{a} " + elt
+    end
+  end
+
+  ###
+  # Unshared prefix, end of run
+
+  return ["0x#{a}..0x#{b} "] if left.zero?
+  
+  ###
+  # Unshared prefix, not end of run
+  # Range can be 0x123456..0x56789A
+  # Which is equivalent to:
+  #     0x123456 .. 0x12FFFF
+  #     0x130000 .. 0x55FFFF
+  #     0x560000 .. 0x56789A
+
+  ret = []
+  ret << build_range(start, a + "FF" * left)
+
+  ###
+  # Only generate middle range if need be.
+
+  if a.hex+1 != b.hex
+    max = to_hex(b.hex - 1)
+    max = "FF" if b == "FF"
+    ret << "0x#{to_hex(a.hex+1)}..0x#{max} " + "0x00..0xFF " * left
+  end
+
+  ###
+  # Don't generate last range if it is covered by first range
+  
+  ret << build_range(b + "00" * left, stop) unless b == "FF"
+  ret.flatten!
+end
+
+def to_utf8( range )
+  utf8_ranges( range ).map do |r|   
+    begin_enc = to_utf8_enc(r.begin)
+    end_enc = to_utf8_enc(r.end)
+    build_range begin_enc, end_enc
+  end.flatten!
+end
+
+##
+# Perform a 3-way comparison of the number of codepoints advertised by
+# the unicode spec for the given range, the originally parsed range,
+# and the resulting utf8 encoded range.
+
+def count_codepoints( code )
+  code.split(' ').inject(1) do |acc, elt|
+    if elt =~ /0x(.+)\.\.0x(.+)/
+      if @encoding == :utf8
+        acc * (from_utf8_enc($2) - from_utf8_enc($1) + 1)
+      else
+        acc * ($2.hex - $1.hex + 1)
+      end
+    else
+      acc
+    end
+  end
+end
+
+def is_valid?( range, desc, codes )
+  spec_count  = 1
+  spec_count  = $1.to_i if desc =~ /\[(\d+)\]/
+  range_count = range.end - range.begin + 1
+
+  sum = codes.inject(0) { |acc, elt| acc + count_codepoints(elt) }
+  sum == spec_count and sum == range_count
+end
+
+##
+# Generate the state maching to stdout
+
+def generate_machine( name, property )
+  pipe = " "
+  @output.puts "    #{name} = "
+  each_alpha( @chart_url, property ) do |range, desc|
+
+    codes = (@encoding == :ucs4) ? to_ucs4(range) : to_utf8(range)
+
+    #raise "Invalid encoding of range #{range}: #{codes.inspect}" unless 
+    #  is_valid? range, desc, codes
+
+    range_width = codes.map { |a| a.size }.max
+    range_width = RANGE_WIDTH if range_width < RANGE_WIDTH
+
+    desc_width  = TOTAL_WIDTH - RANGE_WIDTH - 11
+    desc_width -= (range_width - RANGE_WIDTH) if range_width > RANGE_WIDTH
+
+    if desc.size > desc_width
+      desc = desc[0..desc_width - 4] + "..."
+    end
+
+    codes.each_with_index do |r, idx|
+      desc = "" unless idx.zero?
+      code = "%-#{range_width}s" % r
+      @output.puts "      #{pipe} #{code} ##{desc}"
+      pipe = "|"
+    end
+  end
+  @output.puts "      ;"
+  @output.puts ""
+end
+
+@output.puts <<EOF
+# The following Ragel file was autogenerated with #{$0} 
+# from: #{@chart_url}
+#
+# It defines #{properties}.
+#
+# To use this, make sure that your alphtype is set to #{ALPHTYPES[@encoding]},
+# and that your input is in #{@encoding}.
+
+%%{
+    machine #{machine_name};
+    
+EOF
+
+properties.each { |x| generate_machine( x, x ) }
+
+@output.puts <<EOF
+}%%
+EOF
diff --git a/vendor/github.com/apparentlymart/go-textseg/textseg/utf8_seqs.go b/vendor/github.com/apparentlymart/go-textseg/textseg/utf8_seqs.go
new file mode 100644
index 000000000..6b14bef0e
--- /dev/null
+++ b/vendor/github.com/apparentlymart/go-textseg/textseg/utf8_seqs.go
@@ -0,0 +1,19 @@
+package textseg
+
+import "unicode/utf8"
+
+// ScanGraphemeClusters is a split function for bufio.Scanner that splits
+// on UTF8 sequence boundaries.
+//
+// This is included largely for completeness, since this behavior is already
+// built in to Go when ranging over a string.
+func ScanUTF8Sequences(data []byte, atEOF bool) (int, []byte, error) {
+	if len(data) == 0 {
+		return 0, nil, nil
+	}
+	r, seqLen := utf8.DecodeRune(data)
+	if r == utf8.RuneError && !atEOF {
+		return 0, nil, nil
+	}
+	return seqLen, data[:seqLen], nil
+}
diff --git a/vendor/github.com/coreos/etcd/auth/authpb/auth.pb.go b/vendor/github.com/coreos/etcd/auth/authpb/auth.pb.go
new file mode 100644
index 000000000..009ebda70
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/auth/authpb/auth.pb.go
@@ -0,0 +1,824 @@
+// Code generated by protoc-gen-gogo.
+// source: auth.proto
+// DO NOT EDIT!
+
+/*
+	Package authpb is a generated protocol buffer package.
+
+	It is generated from these files:
+		auth.proto
+
+	It has these top-level messages:
+		User
+		Permission
+		Role
+*/
+package authpb
+
+import (
+	"fmt"
+
+	proto "github.com/golang/protobuf/proto"
+
+	math "math"
+
+	io "io"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type Permission_Type int32
+
+const (
+	READ      Permission_Type = 0
+	WRITE     Permission_Type = 1
+	READWRITE Permission_Type = 2
+)
+
+var Permission_Type_name = map[int32]string{
+	0: "READ",
+	1: "WRITE",
+	2: "READWRITE",
+}
+var Permission_Type_value = map[string]int32{
+	"READ":      0,
+	"WRITE":     1,
+	"READWRITE": 2,
+}
+
+func (x Permission_Type) String() string {
+	return proto.EnumName(Permission_Type_name, int32(x))
+}
+func (Permission_Type) EnumDescriptor() ([]byte, []int) { return fileDescriptorAuth, []int{1, 0} }
+
+// User is a single entry in the bucket authUsers
+type User struct {
+	Name     []byte   `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	Password []byte   `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
+	Roles    []string `protobuf:"bytes,3,rep,name=roles" json:"roles,omitempty"`
+}
+
+func (m *User) Reset()                    { *m = User{} }
+func (m *User) String() string            { return proto.CompactTextString(m) }
+func (*User) ProtoMessage()               {}
+func (*User) Descriptor() ([]byte, []int) { return fileDescriptorAuth, []int{0} }
+
+// Permission is a single entity
+type Permission struct {
+	PermType Permission_Type `protobuf:"varint,1,opt,name=permType,proto3,enum=authpb.Permission_Type" json:"permType,omitempty"`
+	Key      []byte          `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
+	RangeEnd []byte          `protobuf:"bytes,3,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
+}
+
+func (m *Permission) Reset()                    { *m = Permission{} }
+func (m *Permission) String() string            { return proto.CompactTextString(m) }
+func (*Permission) ProtoMessage()               {}
+func (*Permission) Descriptor() ([]byte, []int) { return fileDescriptorAuth, []int{1} }
+
+// Role is a single entry in the bucket authRoles
+type Role struct {
+	Name          []byte        `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	KeyPermission []*Permission `protobuf:"bytes,2,rep,name=keyPermission" json:"keyPermission,omitempty"`
+}
+
+func (m *Role) Reset()                    { *m = Role{} }
+func (m *Role) String() string            { return proto.CompactTextString(m) }
+func (*Role) ProtoMessage()               {}
+func (*Role) Descriptor() ([]byte, []int) { return fileDescriptorAuth, []int{2} }
+
+func init() {
+	proto.RegisterType((*User)(nil), "authpb.User")
+	proto.RegisterType((*Permission)(nil), "authpb.Permission")
+	proto.RegisterType((*Role)(nil), "authpb.Role")
+	proto.RegisterEnum("authpb.Permission_Type", Permission_Type_name, Permission_Type_value)
+}
+func (m *User) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *User) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintAuth(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	if len(m.Password) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintAuth(dAtA, i, uint64(len(m.Password)))
+		i += copy(dAtA[i:], m.Password)
+	}
+	if len(m.Roles) > 0 {
+		for _, s := range m.Roles {
+			dAtA[i] = 0x1a
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
+	}
+	return i, nil
+}
+
+func (m *Permission) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Permission) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.PermType != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintAuth(dAtA, i, uint64(m.PermType))
+	}
+	if len(m.Key) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintAuth(dAtA, i, uint64(len(m.Key)))
+		i += copy(dAtA[i:], m.Key)
+	}
+	if len(m.RangeEnd) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintAuth(dAtA, i, uint64(len(m.RangeEnd)))
+		i += copy(dAtA[i:], m.RangeEnd)
+	}
+	return i, nil
+}
+
+func (m *Role) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Role) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintAuth(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	if len(m.KeyPermission) > 0 {
+		for _, msg := range m.KeyPermission {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintAuth(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	return i, nil
+}
+
+func encodeFixed64Auth(dAtA []byte, offset int, v uint64) int {
+	dAtA[offset] = uint8(v)
+	dAtA[offset+1] = uint8(v >> 8)
+	dAtA[offset+2] = uint8(v >> 16)
+	dAtA[offset+3] = uint8(v >> 24)
+	dAtA[offset+4] = uint8(v >> 32)
+	dAtA[offset+5] = uint8(v >> 40)
+	dAtA[offset+6] = uint8(v >> 48)
+	dAtA[offset+7] = uint8(v >> 56)
+	return offset + 8
+}
+func encodeFixed32Auth(dAtA []byte, offset int, v uint32) int {
+	dAtA[offset] = uint8(v)
+	dAtA[offset+1] = uint8(v >> 8)
+	dAtA[offset+2] = uint8(v >> 16)
+	dAtA[offset+3] = uint8(v >> 24)
+	return offset + 4
+}
+func encodeVarintAuth(dAtA []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return offset + 1
+}
+func (m *User) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovAuth(uint64(l))
+	}
+	l = len(m.Password)
+	if l > 0 {
+		n += 1 + l + sovAuth(uint64(l))
+	}
+	if len(m.Roles) > 0 {
+		for _, s := range m.Roles {
+			l = len(s)
+			n += 1 + l + sovAuth(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *Permission) Size() (n int) {
+	var l int
+	_ = l
+	if m.PermType != 0 {
+		n += 1 + sovAuth(uint64(m.PermType))
+	}
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovAuth(uint64(l))
+	}
+	l = len(m.RangeEnd)
+	if l > 0 {
+		n += 1 + l + sovAuth(uint64(l))
+	}
+	return n
+}
+
+func (m *Role) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovAuth(uint64(l))
+	}
+	if len(m.KeyPermission) > 0 {
+		for _, e := range m.KeyPermission {
+			l = e.Size()
+			n += 1 + l + sovAuth(uint64(l))
+		}
+	}
+	return n
+}
+
+func sovAuth(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozAuth(x uint64) (n int) {
+	return sovAuth(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *User) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowAuth
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: User: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: User: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAuth
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthAuth
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = append(m.Name[:0], dAtA[iNdEx:postIndex]...)
+			if m.Name == nil {
+				m.Name = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAuth
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthAuth
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Password = append(m.Password[:0], dAtA[iNdEx:postIndex]...)
+			if m.Password == nil {
+				m.Password = []byte{}
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAuth
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthAuth
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipAuth(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthAuth
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Permission) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowAuth
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Permission: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Permission: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PermType", wireType)
+			}
+			m.PermType = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAuth
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.PermType |= (Permission_Type(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAuth
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthAuth
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
+			if m.Key == nil {
+				m.Key = []byte{}
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAuth
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthAuth
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.RangeEnd = append(m.RangeEnd[:0], dAtA[iNdEx:postIndex]...)
+			if m.RangeEnd == nil {
+				m.RangeEnd = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipAuth(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthAuth
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Role) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowAuth
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Role: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Role: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAuth
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthAuth
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = append(m.Name[:0], dAtA[iNdEx:postIndex]...)
+			if m.Name == nil {
+				m.Name = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field KeyPermission", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowAuth
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthAuth
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.KeyPermission = append(m.KeyPermission, &Permission{})
+			if err := m.KeyPermission[len(m.KeyPermission)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipAuth(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthAuth
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipAuth(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowAuth
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowAuth
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowAuth
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			iNdEx += length
+			if length < 0 {
+				return 0, ErrInvalidLengthAuth
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowAuth
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipAuth(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthAuth = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowAuth   = fmt.Errorf("proto: integer overflow")
+)
+
+func init() { proto.RegisterFile("auth.proto", fileDescriptorAuth) }
+
+var fileDescriptorAuth = []byte{
+	// 288 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0xc1, 0x4a, 0xc3, 0x30,
+	0x1c, 0xc6, 0x9b, 0xb6, 0x1b, 0xed, 0x5f, 0x27, 0x25, 0x0c, 0x0c, 0x13, 0x42, 0xe9, 0xa9, 0x78,
+	0xa8, 0xb0, 0x5d, 0xbc, 0x2a, 0xf6, 0x20, 0x78, 0x90, 0x50, 0xf1, 0x28, 0x1d, 0x0d, 0x75, 0x6c,
+	0x6d, 0x4a, 0x32, 0x91, 0xbe, 0x89, 0x07, 0x1f, 0x68, 0xc7, 0x3d, 0x82, 0xab, 0x2f, 0x22, 0x4d,
+	0x64, 0x43, 0xdc, 0xed, 0xfb, 0xbe, 0xff, 0x97, 0xe4, 0x97, 0x3f, 0x40, 0xfe, 0xb6, 0x7e, 0x4d,
+	0x1a, 0x29, 0xd6, 0x02, 0x0f, 0x7b, 0xdd, 0xcc, 0x27, 0xe3, 0x52, 0x94, 0x42, 0x47, 0x57, 0xbd,
+	0x32, 0xd3, 0xe8, 0x01, 0xdc, 0x27, 0xc5, 0x25, 0xc6, 0xe0, 0xd6, 0x79, 0xc5, 0x09, 0x0a, 0x51,
+	0x7c, 0xca, 0xb4, 0xc6, 0x13, 0xf0, 0x9a, 0x5c, 0xa9, 0x77, 0x21, 0x0b, 0x62, 0xeb, 0x7c, 0xef,
+	0xf1, 0x18, 0x06, 0x52, 0xac, 0xb8, 0x22, 0x4e, 0xe8, 0xc4, 0x3e, 0x33, 0x26, 0xfa, 0x44, 0x00,
+	0x8f, 0x5c, 0x56, 0x0b, 0xa5, 0x16, 0xa2, 0xc6, 0x33, 0xf0, 0x1a, 0x2e, 0xab, 0xac, 0x6d, 0xcc,
+	0xc5, 0x67, 0xd3, 0xf3, 0xc4, 0xd0, 0x24, 0x87, 0x56, 0xd2, 0x8f, 0xd9, 0xbe, 0x88, 0x03, 0x70,
+	0x96, 0xbc, 0xfd, 0x7d, 0xb0, 0x97, 0xf8, 0x02, 0x7c, 0x99, 0xd7, 0x25, 0x7f, 0xe1, 0x75, 0x41,
+	0x1c, 0x03, 0xa2, 0x83, 0xb4, 0x2e, 0xa2, 0x4b, 0x70, 0xf5, 0x31, 0x0f, 0x5c, 0x96, 0xde, 0xdc,
+	0x05, 0x16, 0xf6, 0x61, 0xf0, 0xcc, 0xee, 0xb3, 0x34, 0x40, 0x78, 0x04, 0x7e, 0x1f, 0x1a, 0x6b,
+	0x47, 0x19, 0xb8, 0x4c, 0xac, 0xf8, 0xd1, 0xcf, 0x5e, 0xc3, 0x68, 0xc9, 0xdb, 0x03, 0x16, 0xb1,
+	0x43, 0x27, 0x3e, 0x99, 0xe2, 0xff, 0xc0, 0xec, 0x6f, 0xf1, 0x96, 0x6c, 0x76, 0xd4, 0xda, 0xee,
+	0xa8, 0xb5, 0xe9, 0x28, 0xda, 0x76, 0x14, 0x7d, 0x75, 0x14, 0x7d, 0x7c, 0x53, 0x6b, 0x3e, 0xd4,
+	0x3b, 0x9e, 0xfd, 0x04, 0x00, 0x00, 0xff, 0xff, 0xcc, 0x76, 0x8d, 0x4f, 0x8f, 0x01, 0x00, 0x00,
+}
diff --git a/vendor/github.com/coreos/etcd/auth/authpb/auth.proto b/vendor/github.com/coreos/etcd/auth/authpb/auth.proto
new file mode 100644
index 000000000..001d33435
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/auth/authpb/auth.proto
@@ -0,0 +1,37 @@
+syntax = "proto3";
+package authpb;
+
+import "gogoproto/gogo.proto";
+
+option (gogoproto.marshaler_all) = true;
+option (gogoproto.sizer_all) = true;
+option (gogoproto.unmarshaler_all) = true;
+option (gogoproto.goproto_getters_all) = false;
+option (gogoproto.goproto_enum_prefix_all) = false;
+
+// User is a single entry in the bucket authUsers
+message User {
+  bytes name = 1;
+  bytes password = 2;
+  repeated string roles = 3;
+}
+
+// Permission is a single entity
+message Permission {
+  enum Type {
+    READ = 0;
+    WRITE = 1;
+    READWRITE = 2;
+  }
+  Type permType = 1;
+
+  bytes key = 2;
+  bytes range_end = 3;
+}
+
+// Role is a single entry in the bucket authRoles
+message Role {
+  bytes name = 1;
+
+  repeated Permission keyPermission = 2;
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/README.md b/vendor/github.com/coreos/etcd/clientv3/README.md
new file mode 100644
index 000000000..376bfba76
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/README.md
@@ -0,0 +1,85 @@
+# etcd/clientv3
+
+[![Godoc](https://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)](https://godoc.org/github.com/coreos/etcd/clientv3)
+
+`etcd/clientv3` is the official Go etcd client for v3.
+
+## Install
+
+```bash
+go get github.com/coreos/etcd/clientv3
+```
+
+## Get started
+
+Create client using `clientv3.New`:
+
+```go
+cli, err := clientv3.New(clientv3.Config{
+	Endpoints:   []string{"localhost:2379", "localhost:22379", "localhost:32379"},
+	DialTimeout: 5 * time.Second,
+})
+if err != nil {
+	// handle error!
+}
+defer cli.Close()
+```
+
+etcd v3 uses [`gRPC`](http://www.grpc.io) for remote procedure calls. And `clientv3` uses
+[`grpc-go`](https://github.com/grpc/grpc-go) to connect to etcd. Make sure to close the client after using it. 
+If the client is not closed, the connection will have leaky goroutines. To specify client request timeout,
+pass `context.WithTimeout` to APIs:
+
+```go
+ctx, cancel := context.WithTimeout(context.Background(), timeout)
+resp, err := cli.Put(ctx, "sample_key", "sample_value")
+cancel()
+if err != nil {
+    // handle error!
+}
+// use the response
+```
+
+etcd uses `cmd/vendor` directory to store external dependencies, which are
+to be compiled into etcd release binaries. `client` can be imported without
+vendoring. For full compatibility, it is recommended to vendor builds using
+etcd's vendored packages, using tools like godep, as in
+[vendor directories](https://golang.org/cmd/go/#hdr-Vendor_Directories).
+For more detail, please read [Go vendor design](https://golang.org/s/go15vendor).
+
+## Error Handling
+
+etcd client returns 2 types of errors:
+
+1. context error: canceled or deadline exceeded.
+2. gRPC error: see [api/v3rpc/rpctypes](https://godoc.org/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes).
+
+Here is the example code to handle client errors:
+
+```go
+resp, err := cli.Put(ctx, "", "")
+if err != nil {
+	switch err {
+	case context.Canceled:
+		log.Fatalf("ctx is canceled by another routine: %v", err)
+	case context.DeadlineExceeded:
+		log.Fatalf("ctx is attached with a deadline is exceeded: %v", err)
+	case rpctypes.ErrEmptyKey:
+		log.Fatalf("client-side error: %v", err)
+	default:
+		log.Fatalf("bad cluster endpoints, which are not etcd servers: %v", err)
+	}
+}
+```
+
+## Metrics
+
+The etcd client optionally exposes RPC metrics through [go-grpc-prometheus](https://github.com/grpc-ecosystem/go-grpc-prometheus). See the [examples](https://github.com/coreos/etcd/blob/master/clientv3/example_metrics_test.go).
+
+## Namespacing
+
+The [namespace](https://godoc.org/github.com/coreos/etcd/clientv3/namespace) package provides `clientv3` interface wrappers to transparently isolate client requests to a user-defined prefix.
+
+## Examples
+
+More code examples can be found at [GoDoc](https://godoc.org/github.com/coreos/etcd/clientv3).
diff --git a/vendor/github.com/coreos/etcd/clientv3/auth.go b/vendor/github.com/coreos/etcd/clientv3/auth.go
new file mode 100644
index 000000000..8df670f16
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/auth.go
@@ -0,0 +1,223 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import (
+	"context"
+	"fmt"
+	"strings"
+
+	"github.com/coreos/etcd/auth/authpb"
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+
+	"google.golang.org/grpc"
+)
+
+type (
+	AuthEnableResponse               pb.AuthEnableResponse
+	AuthDisableResponse              pb.AuthDisableResponse
+	AuthenticateResponse             pb.AuthenticateResponse
+	AuthUserAddResponse              pb.AuthUserAddResponse
+	AuthUserDeleteResponse           pb.AuthUserDeleteResponse
+	AuthUserChangePasswordResponse   pb.AuthUserChangePasswordResponse
+	AuthUserGrantRoleResponse        pb.AuthUserGrantRoleResponse
+	AuthUserGetResponse              pb.AuthUserGetResponse
+	AuthUserRevokeRoleResponse       pb.AuthUserRevokeRoleResponse
+	AuthRoleAddResponse              pb.AuthRoleAddResponse
+	AuthRoleGrantPermissionResponse  pb.AuthRoleGrantPermissionResponse
+	AuthRoleGetResponse              pb.AuthRoleGetResponse
+	AuthRoleRevokePermissionResponse pb.AuthRoleRevokePermissionResponse
+	AuthRoleDeleteResponse           pb.AuthRoleDeleteResponse
+	AuthUserListResponse             pb.AuthUserListResponse
+	AuthRoleListResponse             pb.AuthRoleListResponse
+
+	PermissionType authpb.Permission_Type
+	Permission     authpb.Permission
+)
+
+const (
+	PermRead      = authpb.READ
+	PermWrite     = authpb.WRITE
+	PermReadWrite = authpb.READWRITE
+)
+
+type Auth interface {
+	// AuthEnable enables auth of an etcd cluster.
+	AuthEnable(ctx context.Context) (*AuthEnableResponse, error)
+
+	// AuthDisable disables auth of an etcd cluster.
+	AuthDisable(ctx context.Context) (*AuthDisableResponse, error)
+
+	// UserAdd adds a new user to an etcd cluster.
+	UserAdd(ctx context.Context, name string, password string) (*AuthUserAddResponse, error)
+
+	// UserDelete deletes a user from an etcd cluster.
+	UserDelete(ctx context.Context, name string) (*AuthUserDeleteResponse, error)
+
+	// UserChangePassword changes a password of a user.
+	UserChangePassword(ctx context.Context, name string, password string) (*AuthUserChangePasswordResponse, error)
+
+	// UserGrantRole grants a role to a user.
+	UserGrantRole(ctx context.Context, user string, role string) (*AuthUserGrantRoleResponse, error)
+
+	// UserGet gets a detailed information of a user.
+	UserGet(ctx context.Context, name string) (*AuthUserGetResponse, error)
+
+	// UserList gets a list of all users.
+	UserList(ctx context.Context) (*AuthUserListResponse, error)
+
+	// UserRevokeRole revokes a role of a user.
+	UserRevokeRole(ctx context.Context, name string, role string) (*AuthUserRevokeRoleResponse, error)
+
+	// RoleAdd adds a new role to an etcd cluster.
+	RoleAdd(ctx context.Context, name string) (*AuthRoleAddResponse, error)
+
+	// RoleGrantPermission grants a permission to a role.
+	RoleGrantPermission(ctx context.Context, name string, key, rangeEnd string, permType PermissionType) (*AuthRoleGrantPermissionResponse, error)
+
+	// RoleGet gets a detailed information of a role.
+	RoleGet(ctx context.Context, role string) (*AuthRoleGetResponse, error)
+
+	// RoleList gets a list of all roles.
+	RoleList(ctx context.Context) (*AuthRoleListResponse, error)
+
+	// RoleRevokePermission revokes a permission from a role.
+	RoleRevokePermission(ctx context.Context, role string, key, rangeEnd string) (*AuthRoleRevokePermissionResponse, error)
+
+	// RoleDelete deletes a role.
+	RoleDelete(ctx context.Context, role string) (*AuthRoleDeleteResponse, error)
+}
+
+type auth struct {
+	remote pb.AuthClient
+}
+
+func NewAuth(c *Client) Auth {
+	return &auth{remote: RetryAuthClient(c)}
+}
+
+func (auth *auth) AuthEnable(ctx context.Context) (*AuthEnableResponse, error) {
+	resp, err := auth.remote.AuthEnable(ctx, &pb.AuthEnableRequest{})
+	return (*AuthEnableResponse)(resp), toErr(ctx, err)
+}
+
+func (auth *auth) AuthDisable(ctx context.Context) (*AuthDisableResponse, error) {
+	resp, err := auth.remote.AuthDisable(ctx, &pb.AuthDisableRequest{})
+	return (*AuthDisableResponse)(resp), toErr(ctx, err)
+}
+
+func (auth *auth) UserAdd(ctx context.Context, name string, password string) (*AuthUserAddResponse, error) {
+	resp, err := auth.remote.UserAdd(ctx, &pb.AuthUserAddRequest{Name: name, Password: password})
+	return (*AuthUserAddResponse)(resp), toErr(ctx, err)
+}
+
+func (auth *auth) UserDelete(ctx context.Context, name string) (*AuthUserDeleteResponse, error) {
+	resp, err := auth.remote.UserDelete(ctx, &pb.AuthUserDeleteRequest{Name: name})
+	return (*AuthUserDeleteResponse)(resp), toErr(ctx, err)
+}
+
+func (auth *auth) UserChangePassword(ctx context.Context, name string, password string) (*AuthUserChangePasswordResponse, error) {
+	resp, err := auth.remote.UserChangePassword(ctx, &pb.AuthUserChangePasswordRequest{Name: name, Password: password})
+	return (*AuthUserChangePasswordResponse)(resp), toErr(ctx, err)
+}
+
+func (auth *auth) UserGrantRole(ctx context.Context, user string, role string) (*AuthUserGrantRoleResponse, error) {
+	resp, err := auth.remote.UserGrantRole(ctx, &pb.AuthUserGrantRoleRequest{User: user, Role: role})
+	return (*AuthUserGrantRoleResponse)(resp), toErr(ctx, err)
+}
+
+func (auth *auth) UserGet(ctx context.Context, name string) (*AuthUserGetResponse, error) {
+	resp, err := auth.remote.UserGet(ctx, &pb.AuthUserGetRequest{Name: name})
+	return (*AuthUserGetResponse)(resp), toErr(ctx, err)
+}
+
+func (auth *auth) UserList(ctx context.Context) (*AuthUserListResponse, error) {
+	resp, err := auth.remote.UserList(ctx, &pb.AuthUserListRequest{})
+	return (*AuthUserListResponse)(resp), toErr(ctx, err)
+}
+
+func (auth *auth) UserRevokeRole(ctx context.Context, name string, role string) (*AuthUserRevokeRoleResponse, error) {
+	resp, err := auth.remote.UserRevokeRole(ctx, &pb.AuthUserRevokeRoleRequest{Name: name, Role: role})
+	return (*AuthUserRevokeRoleResponse)(resp), toErr(ctx, err)
+}
+
+func (auth *auth) RoleAdd(ctx context.Context, name string) (*AuthRoleAddResponse, error) {
+	resp, err := auth.remote.RoleAdd(ctx, &pb.AuthRoleAddRequest{Name: name})
+	return (*AuthRoleAddResponse)(resp), toErr(ctx, err)
+}
+
+func (auth *auth) RoleGrantPermission(ctx context.Context, name string, key, rangeEnd string, permType PermissionType) (*AuthRoleGrantPermissionResponse, error) {
+	perm := &authpb.Permission{
+		Key:      []byte(key),
+		RangeEnd: []byte(rangeEnd),
+		PermType: authpb.Permission_Type(permType),
+	}
+	resp, err := auth.remote.RoleGrantPermission(ctx, &pb.AuthRoleGrantPermissionRequest{Name: name, Perm: perm})
+	return (*AuthRoleGrantPermissionResponse)(resp), toErr(ctx, err)
+}
+
+func (auth *auth) RoleGet(ctx context.Context, role string) (*AuthRoleGetResponse, error) {
+	resp, err := auth.remote.RoleGet(ctx, &pb.AuthRoleGetRequest{Role: role})
+	return (*AuthRoleGetResponse)(resp), toErr(ctx, err)
+}
+
+func (auth *auth) RoleList(ctx context.Context) (*AuthRoleListResponse, error) {
+	resp, err := auth.remote.RoleList(ctx, &pb.AuthRoleListRequest{})
+	return (*AuthRoleListResponse)(resp), toErr(ctx, err)
+}
+
+func (auth *auth) RoleRevokePermission(ctx context.Context, role string, key, rangeEnd string) (*AuthRoleRevokePermissionResponse, error) {
+	resp, err := auth.remote.RoleRevokePermission(ctx, &pb.AuthRoleRevokePermissionRequest{Role: role, Key: key, RangeEnd: rangeEnd})
+	return (*AuthRoleRevokePermissionResponse)(resp), toErr(ctx, err)
+}
+
+func (auth *auth) RoleDelete(ctx context.Context, role string) (*AuthRoleDeleteResponse, error) {
+	resp, err := auth.remote.RoleDelete(ctx, &pb.AuthRoleDeleteRequest{Role: role})
+	return (*AuthRoleDeleteResponse)(resp), toErr(ctx, err)
+}
+
+func StrToPermissionType(s string) (PermissionType, error) {
+	val, ok := authpb.Permission_Type_value[strings.ToUpper(s)]
+	if ok {
+		return PermissionType(val), nil
+	}
+	return PermissionType(-1), fmt.Errorf("invalid permission type: %s", s)
+}
+
+type authenticator struct {
+	conn   *grpc.ClientConn // conn in-use
+	remote pb.AuthClient
+}
+
+func (auth *authenticator) authenticate(ctx context.Context, name string, password string) (*AuthenticateResponse, error) {
+	resp, err := auth.remote.Authenticate(ctx, &pb.AuthenticateRequest{Name: name, Password: password})
+	return (*AuthenticateResponse)(resp), toErr(ctx, err)
+}
+
+func (auth *authenticator) close() {
+	auth.conn.Close()
+}
+
+func newAuthenticator(endpoint string, opts []grpc.DialOption) (*authenticator, error) {
+	conn, err := grpc.Dial(endpoint, opts...)
+	if err != nil {
+		return nil, err
+	}
+
+	return &authenticator{
+		conn:   conn,
+		remote: pb.NewAuthClient(conn),
+	}, nil
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/balancer.go b/vendor/github.com/coreos/etcd/clientv3/balancer.go
new file mode 100644
index 000000000..2c8c2981d
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/balancer.go
@@ -0,0 +1,438 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import (
+	"context"
+	"net/url"
+	"strings"
+	"sync"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+)
+
+// ErrNoAddrAvilable is returned by Get() when the balancer does not have
+// any active connection to endpoints at the time.
+// This error is returned only when opts.BlockingWait is true.
+var ErrNoAddrAvilable = grpc.Errorf(codes.Unavailable, "there is no address available")
+
+type notifyMsg int
+
+const (
+	notifyReset notifyMsg = iota
+	notifyNext
+)
+
+// simpleBalancer does the bare minimum to expose multiple eps
+// to the grpc reconnection code path
+type simpleBalancer struct {
+	// addrs are the client's endpoint addresses for grpc
+	addrs []grpc.Address
+
+	// eps holds the raw endpoints from the client
+	eps []string
+
+	// notifyCh notifies grpc of the set of addresses for connecting
+	notifyCh chan []grpc.Address
+
+	// readyc closes once the first connection is up
+	readyc    chan struct{}
+	readyOnce sync.Once
+
+	// mu protects all fields below.
+	mu sync.RWMutex
+
+	// upc closes when pinAddr transitions from empty to non-empty or the balancer closes.
+	upc chan struct{}
+
+	// downc closes when grpc calls down() on pinAddr
+	downc chan struct{}
+
+	// stopc is closed to signal updateNotifyLoop should stop.
+	stopc chan struct{}
+
+	// donec closes when all goroutines are exited
+	donec chan struct{}
+
+	// updateAddrsC notifies updateNotifyLoop to update addrs.
+	updateAddrsC chan notifyMsg
+
+	// grpc issues TLS cert checks using the string passed into dial so
+	// that string must be the host. To recover the full scheme://host URL,
+	// have a map from hosts to the original endpoint.
+	hostPort2ep map[string]string
+
+	// pinAddr is the currently pinned address; set to the empty string on
+	// initialization and shutdown.
+	pinAddr string
+
+	closed bool
+}
+
+func newSimpleBalancer(eps []string) *simpleBalancer {
+	notifyCh := make(chan []grpc.Address)
+	addrs := eps2addrs(eps)
+	sb := &simpleBalancer{
+		addrs:        addrs,
+		eps:          eps,
+		notifyCh:     notifyCh,
+		readyc:       make(chan struct{}),
+		upc:          make(chan struct{}),
+		stopc:        make(chan struct{}),
+		downc:        make(chan struct{}),
+		donec:        make(chan struct{}),
+		updateAddrsC: make(chan notifyMsg),
+		hostPort2ep:  getHostPort2ep(eps),
+	}
+	close(sb.downc)
+	go sb.updateNotifyLoop()
+	return sb
+}
+
+func (b *simpleBalancer) Start(target string, config grpc.BalancerConfig) error { return nil }
+
+func (b *simpleBalancer) ConnectNotify() <-chan struct{} {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.upc
+}
+
+func (b *simpleBalancer) ready() <-chan struct{} { return b.readyc }
+
+func (b *simpleBalancer) endpoint(hostPort string) string {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+	return b.hostPort2ep[hostPort]
+}
+
+func (b *simpleBalancer) endpoints() []string {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+	return b.eps
+}
+
+func (b *simpleBalancer) pinned() string {
+	b.mu.RLock()
+	defer b.mu.RUnlock()
+	return b.pinAddr
+}
+
+func getHostPort2ep(eps []string) map[string]string {
+	hm := make(map[string]string, len(eps))
+	for i := range eps {
+		_, host, _ := parseEndpoint(eps[i])
+		hm[host] = eps[i]
+	}
+	return hm
+}
+
+func (b *simpleBalancer) updateAddrs(eps ...string) {
+	np := getHostPort2ep(eps)
+
+	b.mu.Lock()
+
+	match := len(np) == len(b.hostPort2ep)
+	for k, v := range np {
+		if b.hostPort2ep[k] != v {
+			match = false
+			break
+		}
+	}
+	if match {
+		// same endpoints, so no need to update address
+		b.mu.Unlock()
+		return
+	}
+
+	b.hostPort2ep = np
+	b.addrs, b.eps = eps2addrs(eps), eps
+
+	// updating notifyCh can trigger new connections,
+	// only update addrs if all connections are down
+	// or addrs does not include pinAddr.
+	update := !hasAddr(b.addrs, b.pinAddr)
+	b.mu.Unlock()
+
+	if update {
+		select {
+		case b.updateAddrsC <- notifyNext:
+		case <-b.stopc:
+		}
+	}
+}
+
+func (b *simpleBalancer) next() {
+	b.mu.RLock()
+	downc := b.downc
+	b.mu.RUnlock()
+	select {
+	case b.updateAddrsC <- notifyNext:
+	case <-b.stopc:
+	}
+	// wait until disconnect so new RPCs are not issued on old connection
+	select {
+	case <-downc:
+	case <-b.stopc:
+	}
+}
+
+func hasAddr(addrs []grpc.Address, targetAddr string) bool {
+	for _, addr := range addrs {
+		if targetAddr == addr.Addr {
+			return true
+		}
+	}
+	return false
+}
+
+func (b *simpleBalancer) updateNotifyLoop() {
+	defer close(b.donec)
+
+	for {
+		b.mu.RLock()
+		upc, downc, addr := b.upc, b.downc, b.pinAddr
+		b.mu.RUnlock()
+		// downc or upc should be closed
+		select {
+		case <-downc:
+			downc = nil
+		default:
+		}
+		select {
+		case <-upc:
+			upc = nil
+		default:
+		}
+		switch {
+		case downc == nil && upc == nil:
+			// stale
+			select {
+			case <-b.stopc:
+				return
+			default:
+			}
+		case downc == nil:
+			b.notifyAddrs(notifyReset)
+			select {
+			case <-upc:
+			case msg := <-b.updateAddrsC:
+				b.notifyAddrs(msg)
+			case <-b.stopc:
+				return
+			}
+		case upc == nil:
+			select {
+			// close connections that are not the pinned address
+			case b.notifyCh <- []grpc.Address{{Addr: addr}}:
+			case <-downc:
+			case <-b.stopc:
+				return
+			}
+			select {
+			case <-downc:
+				b.notifyAddrs(notifyReset)
+			case msg := <-b.updateAddrsC:
+				b.notifyAddrs(msg)
+			case <-b.stopc:
+				return
+			}
+		}
+	}
+}
+
+func (b *simpleBalancer) notifyAddrs(msg notifyMsg) {
+	if msg == notifyNext {
+		select {
+		case b.notifyCh <- []grpc.Address{}:
+		case <-b.stopc:
+			return
+		}
+	}
+	b.mu.RLock()
+	addrs := b.addrs
+	pinAddr := b.pinAddr
+	downc := b.downc
+	b.mu.RUnlock()
+
+	var waitDown bool
+	if pinAddr != "" {
+		waitDown = true
+		for _, a := range addrs {
+			if a.Addr == pinAddr {
+				waitDown = false
+			}
+		}
+	}
+
+	select {
+	case b.notifyCh <- addrs:
+		if waitDown {
+			select {
+			case <-downc:
+			case <-b.stopc:
+			}
+		}
+	case <-b.stopc:
+	}
+}
+
+func (b *simpleBalancer) Up(addr grpc.Address) func(error) {
+	f, _ := b.up(addr)
+	return f
+}
+
+func (b *simpleBalancer) up(addr grpc.Address) (func(error), bool) {
+	b.mu.Lock()
+	defer b.mu.Unlock()
+
+	// gRPC might call Up after it called Close. We add this check
+	// to "fix" it up at application layer. Otherwise, will panic
+	// if b.upc is already closed.
+	if b.closed {
+		return func(err error) {}, false
+	}
+	// gRPC might call Up on a stale address.
+	// Prevent updating pinAddr with a stale address.
+	if !hasAddr(b.addrs, addr.Addr) {
+		return func(err error) {}, false
+	}
+	if b.pinAddr != "" {
+		if logger.V(4) {
+			logger.Infof("clientv3/balancer: %q is up but not pinned (already pinned %q)", addr.Addr, b.pinAddr)
+		}
+		return func(err error) {}, false
+	}
+	// notify waiting Get()s and pin first connected address
+	close(b.upc)
+	b.downc = make(chan struct{})
+	b.pinAddr = addr.Addr
+	if logger.V(4) {
+		logger.Infof("clientv3/balancer: pin %q", addr.Addr)
+	}
+	// notify client that a connection is up
+	b.readyOnce.Do(func() { close(b.readyc) })
+	return func(err error) {
+		b.mu.Lock()
+		b.upc = make(chan struct{})
+		close(b.downc)
+		b.pinAddr = ""
+		b.mu.Unlock()
+		if logger.V(4) {
+			logger.Infof("clientv3/balancer: unpin %q (%q)", addr.Addr, err.Error())
+		}
+	}, true
+}
+
+func (b *simpleBalancer) Get(ctx context.Context, opts grpc.BalancerGetOptions) (grpc.Address, func(), error) {
+	var (
+		addr   string
+		closed bool
+	)
+
+	// If opts.BlockingWait is false (for fail-fast RPCs), it should return
+	// an address it has notified via Notify immediately instead of blocking.
+	if !opts.BlockingWait {
+		b.mu.RLock()
+		closed = b.closed
+		addr = b.pinAddr
+		b.mu.RUnlock()
+		if closed {
+			return grpc.Address{Addr: ""}, nil, grpc.ErrClientConnClosing
+		}
+		if addr == "" {
+			return grpc.Address{Addr: ""}, nil, ErrNoAddrAvilable
+		}
+		return grpc.Address{Addr: addr}, func() {}, nil
+	}
+
+	for {
+		b.mu.RLock()
+		ch := b.upc
+		b.mu.RUnlock()
+		select {
+		case <-ch:
+		case <-b.donec:
+			return grpc.Address{Addr: ""}, nil, grpc.ErrClientConnClosing
+		case <-ctx.Done():
+			return grpc.Address{Addr: ""}, nil, ctx.Err()
+		}
+		b.mu.RLock()
+		closed = b.closed
+		addr = b.pinAddr
+		b.mu.RUnlock()
+		// Close() which sets b.closed = true can be called before Get(), Get() must exit if balancer is closed.
+		if closed {
+			return grpc.Address{Addr: ""}, nil, grpc.ErrClientConnClosing
+		}
+		if addr != "" {
+			break
+		}
+	}
+	return grpc.Address{Addr: addr}, func() {}, nil
+}
+
+func (b *simpleBalancer) Notify() <-chan []grpc.Address { return b.notifyCh }
+
+func (b *simpleBalancer) Close() error {
+	b.mu.Lock()
+	// In case gRPC calls close twice. TODO: remove the checking
+	// when we are sure that gRPC wont call close twice.
+	if b.closed {
+		b.mu.Unlock()
+		<-b.donec
+		return nil
+	}
+	b.closed = true
+	close(b.stopc)
+	b.pinAddr = ""
+
+	// In the case of following scenario:
+	//	1. upc is not closed; no pinned address
+	// 	2. client issues an RPC, calling invoke(), which calls Get(), enters for loop, blocks
+	// 	3. client.conn.Close() calls balancer.Close(); closed = true
+	// 	4. for loop in Get() never exits since ctx is the context passed in by the client and may not be canceled
+	// we must close upc so Get() exits from blocking on upc
+	select {
+	case <-b.upc:
+	default:
+		// terminate all waiting Get()s
+		close(b.upc)
+	}
+
+	b.mu.Unlock()
+
+	// wait for updateNotifyLoop to finish
+	<-b.donec
+	close(b.notifyCh)
+
+	return nil
+}
+
+func getHost(ep string) string {
+	url, uerr := url.Parse(ep)
+	if uerr != nil || !strings.Contains(ep, "://") {
+		return ep
+	}
+	return url.Host
+}
+
+func eps2addrs(eps []string) []grpc.Address {
+	addrs := make([]grpc.Address, len(eps))
+	for i := range eps {
+		addrs[i].Addr = getHost(eps[i])
+	}
+	return addrs
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/client.go b/vendor/github.com/coreos/etcd/clientv3/client.go
new file mode 100644
index 000000000..bff7d7cc6
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/client.go
@@ -0,0 +1,528 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import (
+	"context"
+	"crypto/tls"
+	"errors"
+	"fmt"
+	"net"
+	"net/url"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/credentials"
+	"google.golang.org/grpc/keepalive"
+	"google.golang.org/grpc/metadata"
+	"google.golang.org/grpc/status"
+)
+
+var (
+	ErrNoAvailableEndpoints = errors.New("etcdclient: no available endpoints")
+	ErrOldCluster           = errors.New("etcdclient: old cluster version")
+)
+
+// Client provides and manages an etcd v3 client session.
+type Client struct {
+	Cluster
+	KV
+	Lease
+	Watcher
+	Auth
+	Maintenance
+
+	conn     *grpc.ClientConn
+	dialerrc chan error
+
+	cfg      Config
+	creds    *credentials.TransportCredentials
+	balancer *healthBalancer
+	mu       sync.Mutex
+
+	ctx    context.Context
+	cancel context.CancelFunc
+
+	// Username is a user name for authentication.
+	Username string
+	// Password is a password for authentication.
+	Password string
+	// tokenCred is an instance of WithPerRPCCredentials()'s argument
+	tokenCred *authTokenCredential
+}
+
+// New creates a new etcdv3 client from a given configuration.
+func New(cfg Config) (*Client, error) {
+	if len(cfg.Endpoints) == 0 {
+		return nil, ErrNoAvailableEndpoints
+	}
+
+	return newClient(&cfg)
+}
+
+// NewCtxClient creates a client with a context but no underlying grpc
+// connection. This is useful for embedded cases that override the
+// service interface implementations and do not need connection management.
+func NewCtxClient(ctx context.Context) *Client {
+	cctx, cancel := context.WithCancel(ctx)
+	return &Client{ctx: cctx, cancel: cancel}
+}
+
+// NewFromURL creates a new etcdv3 client from a URL.
+func NewFromURL(url string) (*Client, error) {
+	return New(Config{Endpoints: []string{url}})
+}
+
+// Close shuts down the client's etcd connections.
+func (c *Client) Close() error {
+	c.cancel()
+	c.Watcher.Close()
+	c.Lease.Close()
+	if c.conn != nil {
+		return toErr(c.ctx, c.conn.Close())
+	}
+	return c.ctx.Err()
+}
+
+// Ctx is a context for "out of band" messages (e.g., for sending
+// "clean up" message when another context is canceled). It is
+// canceled on client Close().
+func (c *Client) Ctx() context.Context { return c.ctx }
+
+// Endpoints lists the registered endpoints for the client.
+func (c *Client) Endpoints() (eps []string) {
+	// copy the slice; protect original endpoints from being changed
+	eps = make([]string, len(c.cfg.Endpoints))
+	copy(eps, c.cfg.Endpoints)
+	return
+}
+
+// SetEndpoints updates client's endpoints.
+func (c *Client) SetEndpoints(eps ...string) {
+	c.mu.Lock()
+	c.cfg.Endpoints = eps
+	c.mu.Unlock()
+	c.balancer.updateAddrs(eps...)
+}
+
+// Sync synchronizes client's endpoints with the known endpoints from the etcd membership.
+func (c *Client) Sync(ctx context.Context) error {
+	mresp, err := c.MemberList(ctx)
+	if err != nil {
+		return err
+	}
+	var eps []string
+	for _, m := range mresp.Members {
+		eps = append(eps, m.ClientURLs...)
+	}
+	c.SetEndpoints(eps...)
+	return nil
+}
+
+func (c *Client) autoSync() {
+	if c.cfg.AutoSyncInterval == time.Duration(0) {
+		return
+	}
+
+	for {
+		select {
+		case <-c.ctx.Done():
+			return
+		case <-time.After(c.cfg.AutoSyncInterval):
+			ctx, cancel := context.WithTimeout(c.ctx, 5*time.Second)
+			err := c.Sync(ctx)
+			cancel()
+			if err != nil && err != c.ctx.Err() {
+				logger.Println("Auto sync endpoints failed:", err)
+			}
+		}
+	}
+}
+
+type authTokenCredential struct {
+	token   string
+	tokenMu *sync.RWMutex
+}
+
+func (cred authTokenCredential) RequireTransportSecurity() bool {
+	return false
+}
+
+func (cred authTokenCredential) GetRequestMetadata(ctx context.Context, s ...string) (map[string]string, error) {
+	cred.tokenMu.RLock()
+	defer cred.tokenMu.RUnlock()
+	return map[string]string{
+		"token": cred.token,
+	}, nil
+}
+
+func parseEndpoint(endpoint string) (proto string, host string, scheme string) {
+	proto = "tcp"
+	host = endpoint
+	url, uerr := url.Parse(endpoint)
+	if uerr != nil || !strings.Contains(endpoint, "://") {
+		return
+	}
+	scheme = url.Scheme
+
+	// strip scheme:// prefix since grpc dials by host
+	host = url.Host
+	switch url.Scheme {
+	case "http", "https":
+	case "unix", "unixs":
+		proto = "unix"
+		host = url.Host + url.Path
+	default:
+		proto, host = "", ""
+	}
+	return
+}
+
+func (c *Client) processCreds(scheme string) (creds *credentials.TransportCredentials) {
+	creds = c.creds
+	switch scheme {
+	case "unix":
+	case "http":
+		creds = nil
+	case "https", "unixs":
+		if creds != nil {
+			break
+		}
+		tlsconfig := &tls.Config{}
+		emptyCreds := credentials.NewTLS(tlsconfig)
+		creds = &emptyCreds
+	default:
+		creds = nil
+	}
+	return
+}
+
+// dialSetupOpts gives the dial opts prior to any authentication
+func (c *Client) dialSetupOpts(endpoint string, dopts ...grpc.DialOption) (opts []grpc.DialOption) {
+	if c.cfg.DialTimeout > 0 {
+		opts = []grpc.DialOption{grpc.WithTimeout(c.cfg.DialTimeout)}
+	}
+	if c.cfg.DialKeepAliveTime > 0 {
+		params := keepalive.ClientParameters{
+			Time:    c.cfg.DialKeepAliveTime,
+			Timeout: c.cfg.DialKeepAliveTimeout,
+		}
+		opts = append(opts, grpc.WithKeepaliveParams(params))
+	}
+	opts = append(opts, dopts...)
+
+	f := func(host string, t time.Duration) (net.Conn, error) {
+		proto, host, _ := parseEndpoint(c.balancer.endpoint(host))
+		if host == "" && endpoint != "" {
+			// dialing an endpoint not in the balancer; use
+			// endpoint passed into dial
+			proto, host, _ = parseEndpoint(endpoint)
+		}
+		if proto == "" {
+			return nil, fmt.Errorf("unknown scheme for %q", host)
+		}
+		select {
+		case <-c.ctx.Done():
+			return nil, c.ctx.Err()
+		default:
+		}
+		dialer := &net.Dialer{Timeout: t}
+		conn, err := dialer.DialContext(c.ctx, proto, host)
+		if err != nil {
+			select {
+			case c.dialerrc <- err:
+			default:
+			}
+		}
+		return conn, err
+	}
+	opts = append(opts, grpc.WithDialer(f))
+
+	creds := c.creds
+	if _, _, scheme := parseEndpoint(endpoint); len(scheme) != 0 {
+		creds = c.processCreds(scheme)
+	}
+	if creds != nil {
+		opts = append(opts, grpc.WithTransportCredentials(*creds))
+	} else {
+		opts = append(opts, grpc.WithInsecure())
+	}
+
+	return opts
+}
+
+// Dial connects to a single endpoint using the client's config.
+func (c *Client) Dial(endpoint string) (*grpc.ClientConn, error) {
+	return c.dial(endpoint)
+}
+
+func (c *Client) getToken(ctx context.Context) error {
+	var err error // return last error in a case of fail
+	var auth *authenticator
+
+	for i := 0; i < len(c.cfg.Endpoints); i++ {
+		endpoint := c.cfg.Endpoints[i]
+		host := getHost(endpoint)
+		// use dial options without dopts to avoid reusing the client balancer
+		auth, err = newAuthenticator(host, c.dialSetupOpts(endpoint))
+		if err != nil {
+			continue
+		}
+		defer auth.close()
+
+		var resp *AuthenticateResponse
+		resp, err = auth.authenticate(ctx, c.Username, c.Password)
+		if err != nil {
+			continue
+		}
+
+		c.tokenCred.tokenMu.Lock()
+		c.tokenCred.token = resp.Token
+		c.tokenCred.tokenMu.Unlock()
+
+		return nil
+	}
+
+	return err
+}
+
+func (c *Client) dial(endpoint string, dopts ...grpc.DialOption) (*grpc.ClientConn, error) {
+	opts := c.dialSetupOpts(endpoint, dopts...)
+	host := getHost(endpoint)
+	if c.Username != "" && c.Password != "" {
+		c.tokenCred = &authTokenCredential{
+			tokenMu: &sync.RWMutex{},
+		}
+
+		ctx := c.ctx
+		if c.cfg.DialTimeout > 0 {
+			cctx, cancel := context.WithTimeout(ctx, c.cfg.DialTimeout)
+			defer cancel()
+			ctx = cctx
+		}
+
+		err := c.getToken(ctx)
+		if err != nil {
+			if toErr(ctx, err) != rpctypes.ErrAuthNotEnabled {
+				if err == ctx.Err() && ctx.Err() != c.ctx.Err() {
+					err = context.DeadlineExceeded
+				}
+				return nil, err
+			}
+		} else {
+			opts = append(opts, grpc.WithPerRPCCredentials(c.tokenCred))
+		}
+	}
+
+	opts = append(opts, c.cfg.DialOptions...)
+
+	conn, err := grpc.DialContext(c.ctx, host, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return conn, nil
+}
+
+// WithRequireLeader requires client requests to only succeed
+// when the cluster has a leader.
+func WithRequireLeader(ctx context.Context) context.Context {
+	md := metadata.Pairs(rpctypes.MetadataRequireLeaderKey, rpctypes.MetadataHasLeader)
+	return metadata.NewOutgoingContext(ctx, md)
+}
+
+func newClient(cfg *Config) (*Client, error) {
+	if cfg == nil {
+		cfg = &Config{}
+	}
+	var creds *credentials.TransportCredentials
+	if cfg.TLS != nil {
+		c := credentials.NewTLS(cfg.TLS)
+		creds = &c
+	}
+
+	// use a temporary skeleton client to bootstrap first connection
+	baseCtx := context.TODO()
+	if cfg.Context != nil {
+		baseCtx = cfg.Context
+	}
+
+	ctx, cancel := context.WithCancel(baseCtx)
+	client := &Client{
+		conn:     nil,
+		dialerrc: make(chan error, 1),
+		cfg:      *cfg,
+		creds:    creds,
+		ctx:      ctx,
+		cancel:   cancel,
+	}
+	if cfg.Username != "" && cfg.Password != "" {
+		client.Username = cfg.Username
+		client.Password = cfg.Password
+	}
+
+	sb := newSimpleBalancer(cfg.Endpoints)
+	hc := func(ep string) (bool, error) { return grpcHealthCheck(client, ep) }
+	client.balancer = newHealthBalancer(sb, cfg.DialTimeout, hc)
+
+	// use Endpoints[0] so that for https:// without any tls config given, then
+	// grpc will assume the certificate server name is the endpoint host.
+	conn, err := client.dial(cfg.Endpoints[0], grpc.WithBalancer(client.balancer))
+	if err != nil {
+		client.cancel()
+		client.balancer.Close()
+		return nil, err
+	}
+	client.conn = conn
+
+	// wait for a connection
+	if cfg.DialTimeout > 0 {
+		hasConn := false
+		waitc := time.After(cfg.DialTimeout)
+		select {
+		case <-client.balancer.ready():
+			hasConn = true
+		case <-ctx.Done():
+		case <-waitc:
+		}
+		if !hasConn {
+			err := context.DeadlineExceeded
+			select {
+			case err = <-client.dialerrc:
+			default:
+			}
+			client.cancel()
+			client.balancer.Close()
+			conn.Close()
+			return nil, err
+		}
+	}
+
+	client.Cluster = NewCluster(client)
+	client.KV = NewKV(client)
+	client.Lease = NewLease(client)
+	client.Watcher = NewWatcher(client)
+	client.Auth = NewAuth(client)
+	client.Maintenance = NewMaintenance(client)
+
+	if cfg.RejectOldCluster {
+		if err := client.checkVersion(); err != nil {
+			client.Close()
+			return nil, err
+		}
+	}
+
+	go client.autoSync()
+	return client, nil
+}
+
+func (c *Client) checkVersion() (err error) {
+	var wg sync.WaitGroup
+	errc := make(chan error, len(c.cfg.Endpoints))
+	ctx, cancel := context.WithCancel(c.ctx)
+	if c.cfg.DialTimeout > 0 {
+		ctx, cancel = context.WithTimeout(ctx, c.cfg.DialTimeout)
+	}
+	wg.Add(len(c.cfg.Endpoints))
+	for _, ep := range c.cfg.Endpoints {
+		// if cluster is current, any endpoint gives a recent version
+		go func(e string) {
+			defer wg.Done()
+			resp, rerr := c.Status(ctx, e)
+			if rerr != nil {
+				errc <- rerr
+				return
+			}
+			vs := strings.Split(resp.Version, ".")
+			maj, min := 0, 0
+			if len(vs) >= 2 {
+				maj, _ = strconv.Atoi(vs[0])
+				min, rerr = strconv.Atoi(vs[1])
+			}
+			if maj < 3 || (maj == 3 && min < 2) {
+				rerr = ErrOldCluster
+			}
+			errc <- rerr
+		}(ep)
+	}
+	// wait for success
+	for i := 0; i < len(c.cfg.Endpoints); i++ {
+		if err = <-errc; err == nil {
+			break
+		}
+	}
+	cancel()
+	wg.Wait()
+	return err
+}
+
+// ActiveConnection returns the current in-use connection
+func (c *Client) ActiveConnection() *grpc.ClientConn { return c.conn }
+
+// isHaltErr returns true if the given error and context indicate no forward
+// progress can be made, even after reconnecting.
+func isHaltErr(ctx context.Context, err error) bool {
+	if ctx != nil && ctx.Err() != nil {
+		return true
+	}
+	if err == nil {
+		return false
+	}
+	ev, _ := status.FromError(err)
+	// Unavailable codes mean the system will be right back.
+	// (e.g., can't connect, lost leader)
+	// Treat Internal codes as if something failed, leaving the
+	// system in an inconsistent state, but retrying could make progress.
+	// (e.g., failed in middle of send, corrupted frame)
+	// TODO: are permanent Internal errors possible from grpc?
+	return ev.Code() != codes.Unavailable && ev.Code() != codes.Internal
+}
+
+func toErr(ctx context.Context, err error) error {
+	if err == nil {
+		return nil
+	}
+	err = rpctypes.Error(err)
+	if _, ok := err.(rpctypes.EtcdError); ok {
+		return err
+	}
+	ev, _ := status.FromError(err)
+	code := ev.Code()
+	switch code {
+	case codes.DeadlineExceeded:
+		fallthrough
+	case codes.Canceled:
+		if ctx.Err() != nil {
+			err = ctx.Err()
+		}
+	case codes.Unavailable:
+	case codes.FailedPrecondition:
+		err = grpc.ErrClientConnClosing
+	}
+	return err
+}
+
+func canceledByCaller(stopCtx context.Context, err error) bool {
+	if stopCtx.Err() == nil || err == nil {
+		return false
+	}
+
+	return err == context.Canceled || err == context.DeadlineExceeded
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/cluster.go b/vendor/github.com/coreos/etcd/clientv3/cluster.go
new file mode 100644
index 000000000..8beba58a6
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/cluster.go
@@ -0,0 +1,92 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import (
+	"context"
+
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+)
+
+type (
+	Member               pb.Member
+	MemberListResponse   pb.MemberListResponse
+	MemberAddResponse    pb.MemberAddResponse
+	MemberRemoveResponse pb.MemberRemoveResponse
+	MemberUpdateResponse pb.MemberUpdateResponse
+)
+
+type Cluster interface {
+	// MemberList lists the current cluster membership.
+	MemberList(ctx context.Context) (*MemberListResponse, error)
+
+	// MemberAdd adds a new member into the cluster.
+	MemberAdd(ctx context.Context, peerAddrs []string) (*MemberAddResponse, error)
+
+	// MemberRemove removes an existing member from the cluster.
+	MemberRemove(ctx context.Context, id uint64) (*MemberRemoveResponse, error)
+
+	// MemberUpdate updates the peer addresses of the member.
+	MemberUpdate(ctx context.Context, id uint64, peerAddrs []string) (*MemberUpdateResponse, error)
+}
+
+type cluster struct {
+	remote pb.ClusterClient
+}
+
+func NewCluster(c *Client) Cluster {
+	return &cluster{remote: RetryClusterClient(c)}
+}
+
+func NewClusterFromClusterClient(remote pb.ClusterClient) Cluster {
+	return &cluster{remote: remote}
+}
+
+func (c *cluster) MemberAdd(ctx context.Context, peerAddrs []string) (*MemberAddResponse, error) {
+	r := &pb.MemberAddRequest{PeerURLs: peerAddrs}
+	resp, err := c.remote.MemberAdd(ctx, r)
+	if err != nil {
+		return nil, toErr(ctx, err)
+	}
+	return (*MemberAddResponse)(resp), nil
+}
+
+func (c *cluster) MemberRemove(ctx context.Context, id uint64) (*MemberRemoveResponse, error) {
+	r := &pb.MemberRemoveRequest{ID: id}
+	resp, err := c.remote.MemberRemove(ctx, r)
+	if err != nil {
+		return nil, toErr(ctx, err)
+	}
+	return (*MemberRemoveResponse)(resp), nil
+}
+
+func (c *cluster) MemberUpdate(ctx context.Context, id uint64, peerAddrs []string) (*MemberUpdateResponse, error) {
+	// it is safe to retry on update.
+	r := &pb.MemberUpdateRequest{ID: id, PeerURLs: peerAddrs}
+	resp, err := c.remote.MemberUpdate(ctx, r)
+	if err == nil {
+		return (*MemberUpdateResponse)(resp), nil
+	}
+	return nil, toErr(ctx, err)
+}
+
+func (c *cluster) MemberList(ctx context.Context) (*MemberListResponse, error) {
+	// it is safe to retry on list.
+	resp, err := c.remote.MemberList(ctx, &pb.MemberListRequest{})
+	if err == nil {
+		return (*MemberListResponse)(resp), nil
+	}
+	return nil, toErr(ctx, err)
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/compact_op.go b/vendor/github.com/coreos/etcd/clientv3/compact_op.go
new file mode 100644
index 000000000..41e80c1da
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/compact_op.go
@@ -0,0 +1,51 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import (
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+)
+
+// CompactOp represents a compact operation.
+type CompactOp struct {
+	revision int64
+	physical bool
+}
+
+// CompactOption configures compact operation.
+type CompactOption func(*CompactOp)
+
+func (op *CompactOp) applyCompactOpts(opts []CompactOption) {
+	for _, opt := range opts {
+		opt(op)
+	}
+}
+
+// OpCompact wraps slice CompactOption to create a CompactOp.
+func OpCompact(rev int64, opts ...CompactOption) CompactOp {
+	ret := CompactOp{revision: rev}
+	ret.applyCompactOpts(opts)
+	return ret
+}
+
+func (op CompactOp) toRequest() *pb.CompactionRequest {
+	return &pb.CompactionRequest{Revision: op.revision, Physical: op.physical}
+}
+
+// WithCompactPhysical makes Compact wait until all compacted entries are
+// removed from the etcd server's storage.
+func WithCompactPhysical() CompactOption {
+	return func(op *CompactOp) { op.physical = true }
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/compare.go b/vendor/github.com/coreos/etcd/clientv3/compare.go
new file mode 100644
index 000000000..b5f0a2552
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/compare.go
@@ -0,0 +1,140 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import (
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+)
+
+type CompareTarget int
+type CompareResult int
+
+const (
+	CompareVersion CompareTarget = iota
+	CompareCreated
+	CompareModified
+	CompareValue
+)
+
+type Cmp pb.Compare
+
+func Compare(cmp Cmp, result string, v interface{}) Cmp {
+	var r pb.Compare_CompareResult
+
+	switch result {
+	case "=":
+		r = pb.Compare_EQUAL
+	case "!=":
+		r = pb.Compare_NOT_EQUAL
+	case ">":
+		r = pb.Compare_GREATER
+	case "<":
+		r = pb.Compare_LESS
+	default:
+		panic("Unknown result op")
+	}
+
+	cmp.Result = r
+	switch cmp.Target {
+	case pb.Compare_VALUE:
+		val, ok := v.(string)
+		if !ok {
+			panic("bad compare value")
+		}
+		cmp.TargetUnion = &pb.Compare_Value{Value: []byte(val)}
+	case pb.Compare_VERSION:
+		cmp.TargetUnion = &pb.Compare_Version{Version: mustInt64(v)}
+	case pb.Compare_CREATE:
+		cmp.TargetUnion = &pb.Compare_CreateRevision{CreateRevision: mustInt64(v)}
+	case pb.Compare_MOD:
+		cmp.TargetUnion = &pb.Compare_ModRevision{ModRevision: mustInt64(v)}
+	case pb.Compare_LEASE:
+		cmp.TargetUnion = &pb.Compare_Lease{Lease: mustInt64orLeaseID(v)}
+	default:
+		panic("Unknown compare type")
+	}
+	return cmp
+}
+
+func Value(key string) Cmp {
+	return Cmp{Key: []byte(key), Target: pb.Compare_VALUE}
+}
+
+func Version(key string) Cmp {
+	return Cmp{Key: []byte(key), Target: pb.Compare_VERSION}
+}
+
+func CreateRevision(key string) Cmp {
+	return Cmp{Key: []byte(key), Target: pb.Compare_CREATE}
+}
+
+func ModRevision(key string) Cmp {
+	return Cmp{Key: []byte(key), Target: pb.Compare_MOD}
+}
+
+// LeaseValue compares a key's LeaseID to a value of your choosing. The empty
+// LeaseID is 0, otherwise known as `NoLease`.
+func LeaseValue(key string) Cmp {
+	return Cmp{Key: []byte(key), Target: pb.Compare_LEASE}
+}
+
+// KeyBytes returns the byte slice holding with the comparison key.
+func (cmp *Cmp) KeyBytes() []byte { return cmp.Key }
+
+// WithKeyBytes sets the byte slice for the comparison key.
+func (cmp *Cmp) WithKeyBytes(key []byte) { cmp.Key = key }
+
+// ValueBytes returns the byte slice holding the comparison value, if any.
+func (cmp *Cmp) ValueBytes() []byte {
+	if tu, ok := cmp.TargetUnion.(*pb.Compare_Value); ok {
+		return tu.Value
+	}
+	return nil
+}
+
+// WithValueBytes sets the byte slice for the comparison's value.
+func (cmp *Cmp) WithValueBytes(v []byte) { cmp.TargetUnion.(*pb.Compare_Value).Value = v }
+
+// WithRange sets the comparison to scan the range [key, end).
+func (cmp Cmp) WithRange(end string) Cmp {
+	cmp.RangeEnd = []byte(end)
+	return cmp
+}
+
+// WithPrefix sets the comparison to scan all keys prefixed by the key.
+func (cmp Cmp) WithPrefix() Cmp {
+	cmp.RangeEnd = getPrefix(cmp.Key)
+	return cmp
+}
+
+// mustInt64 panics if val isn't an int or int64. It returns an int64 otherwise.
+func mustInt64(val interface{}) int64 {
+	if v, ok := val.(int64); ok {
+		return v
+	}
+	if v, ok := val.(int); ok {
+		return int64(v)
+	}
+	panic("bad value")
+}
+
+// mustInt64orLeaseID panics if val isn't a LeaseID, int or int64. It returns an
+// int64 otherwise.
+func mustInt64orLeaseID(val interface{}) int64 {
+	if v, ok := val.(LeaseID); ok {
+		return int64(v)
+	}
+	return mustInt64(val)
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/concurrency/doc.go b/vendor/github.com/coreos/etcd/clientv3/concurrency/doc.go
new file mode 100644
index 000000000..dcdbf511d
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/concurrency/doc.go
@@ -0,0 +1,17 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package concurrency implements concurrency operations on top of
+// etcd such as distributed locks, barriers, and elections.
+package concurrency
diff --git a/vendor/github.com/coreos/etcd/clientv3/concurrency/election.go b/vendor/github.com/coreos/etcd/clientv3/concurrency/election.go
new file mode 100644
index 000000000..e18a0ed4a
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/concurrency/election.go
@@ -0,0 +1,245 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package concurrency
+
+import (
+	"context"
+	"errors"
+	"fmt"
+
+	v3 "github.com/coreos/etcd/clientv3"
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/mvcc/mvccpb"
+)
+
+var (
+	ErrElectionNotLeader = errors.New("election: not leader")
+	ErrElectionNoLeader  = errors.New("election: no leader")
+)
+
+type Election struct {
+	session *Session
+
+	keyPrefix string
+
+	leaderKey     string
+	leaderRev     int64
+	leaderSession *Session
+	hdr           *pb.ResponseHeader
+}
+
+// NewElection returns a new election on a given key prefix.
+func NewElection(s *Session, pfx string) *Election {
+	return &Election{session: s, keyPrefix: pfx + "/"}
+}
+
+// ResumeElection initializes an election with a known leader.
+func ResumeElection(s *Session, pfx string, leaderKey string, leaderRev int64) *Election {
+	return &Election{
+		session:       s,
+		leaderKey:     leaderKey,
+		leaderRev:     leaderRev,
+		leaderSession: s,
+	}
+}
+
+// Campaign puts a value as eligible for the election. It blocks until
+// it is elected, an error occurs, or the context is cancelled.
+func (e *Election) Campaign(ctx context.Context, val string) error {
+	s := e.session
+	client := e.session.Client()
+
+	k := fmt.Sprintf("%s%x", e.keyPrefix, s.Lease())
+	txn := client.Txn(ctx).If(v3.Compare(v3.CreateRevision(k), "=", 0))
+	txn = txn.Then(v3.OpPut(k, val, v3.WithLease(s.Lease())))
+	txn = txn.Else(v3.OpGet(k))
+	resp, err := txn.Commit()
+	if err != nil {
+		return err
+	}
+	e.leaderKey, e.leaderRev, e.leaderSession = k, resp.Header.Revision, s
+	if !resp.Succeeded {
+		kv := resp.Responses[0].GetResponseRange().Kvs[0]
+		e.leaderRev = kv.CreateRevision
+		if string(kv.Value) != val {
+			if err = e.Proclaim(ctx, val); err != nil {
+				e.Resign(ctx)
+				return err
+			}
+		}
+	}
+
+	_, err = waitDeletes(ctx, client, e.keyPrefix, e.leaderRev-1)
+	if err != nil {
+		// clean up in case of context cancel
+		select {
+		case <-ctx.Done():
+			e.Resign(client.Ctx())
+		default:
+			e.leaderSession = nil
+		}
+		return err
+	}
+	e.hdr = resp.Header
+
+	return nil
+}
+
+// Proclaim lets the leader announce a new value without another election.
+func (e *Election) Proclaim(ctx context.Context, val string) error {
+	if e.leaderSession == nil {
+		return ErrElectionNotLeader
+	}
+	client := e.session.Client()
+	cmp := v3.Compare(v3.CreateRevision(e.leaderKey), "=", e.leaderRev)
+	txn := client.Txn(ctx).If(cmp)
+	txn = txn.Then(v3.OpPut(e.leaderKey, val, v3.WithLease(e.leaderSession.Lease())))
+	tresp, terr := txn.Commit()
+	if terr != nil {
+		return terr
+	}
+	if !tresp.Succeeded {
+		e.leaderKey = ""
+		return ErrElectionNotLeader
+	}
+
+	e.hdr = tresp.Header
+	return nil
+}
+
+// Resign lets a leader start a new election.
+func (e *Election) Resign(ctx context.Context) (err error) {
+	if e.leaderSession == nil {
+		return nil
+	}
+	client := e.session.Client()
+	cmp := v3.Compare(v3.CreateRevision(e.leaderKey), "=", e.leaderRev)
+	resp, err := client.Txn(ctx).If(cmp).Then(v3.OpDelete(e.leaderKey)).Commit()
+	if err == nil {
+		e.hdr = resp.Header
+	}
+	e.leaderKey = ""
+	e.leaderSession = nil
+	return err
+}
+
+// Leader returns the leader value for the current election.
+func (e *Election) Leader(ctx context.Context) (*v3.GetResponse, error) {
+	client := e.session.Client()
+	resp, err := client.Get(ctx, e.keyPrefix, v3.WithFirstCreate()...)
+	if err != nil {
+		return nil, err
+	} else if len(resp.Kvs) == 0 {
+		// no leader currently elected
+		return nil, ErrElectionNoLeader
+	}
+	return resp, nil
+}
+
+// Observe returns a channel that reliably observes ordered leader proposals
+// as GetResponse values on every current elected leader key. It will not
+// necessarily fetch all historical leader updates, but will always post the
+// most recent leader value.
+//
+// The channel closes when the context is canceled or the underlying watcher
+// is otherwise disrupted.
+func (e *Election) Observe(ctx context.Context) <-chan v3.GetResponse {
+	retc := make(chan v3.GetResponse)
+	go e.observe(ctx, retc)
+	return retc
+}
+
+func (e *Election) observe(ctx context.Context, ch chan<- v3.GetResponse) {
+	client := e.session.Client()
+
+	defer close(ch)
+	for {
+		resp, err := client.Get(ctx, e.keyPrefix, v3.WithFirstCreate()...)
+		if err != nil {
+			return
+		}
+
+		var kv *mvccpb.KeyValue
+		var hdr *pb.ResponseHeader
+
+		if len(resp.Kvs) == 0 {
+			cctx, cancel := context.WithCancel(ctx)
+			// wait for first key put on prefix
+			opts := []v3.OpOption{v3.WithRev(resp.Header.Revision), v3.WithPrefix()}
+			wch := client.Watch(cctx, e.keyPrefix, opts...)
+			for kv == nil {
+				wr, ok := <-wch
+				if !ok || wr.Err() != nil {
+					cancel()
+					return
+				}
+				// only accept puts; a delete will make observe() spin
+				for _, ev := range wr.Events {
+					if ev.Type == mvccpb.PUT {
+						hdr, kv = &wr.Header, ev.Kv
+						// may have multiple revs; hdr.rev = the last rev
+						// set to kv's rev in case batch has multiple Puts
+						hdr.Revision = kv.ModRevision
+						break
+					}
+				}
+			}
+			cancel()
+		} else {
+			hdr, kv = resp.Header, resp.Kvs[0]
+		}
+
+		select {
+		case ch <- v3.GetResponse{Header: hdr, Kvs: []*mvccpb.KeyValue{kv}}:
+		case <-ctx.Done():
+			return
+		}
+
+		cctx, cancel := context.WithCancel(ctx)
+		wch := client.Watch(cctx, string(kv.Key), v3.WithRev(hdr.Revision+1))
+		keyDeleted := false
+		for !keyDeleted {
+			wr, ok := <-wch
+			if !ok {
+				cancel()
+				return
+			}
+			for _, ev := range wr.Events {
+				if ev.Type == mvccpb.DELETE {
+					keyDeleted = true
+					break
+				}
+				resp.Header = &wr.Header
+				resp.Kvs = []*mvccpb.KeyValue{ev.Kv}
+				select {
+				case ch <- *resp:
+				case <-cctx.Done():
+					cancel()
+					return
+				}
+			}
+		}
+		cancel()
+	}
+}
+
+// Key returns the leader key if elected, empty string otherwise.
+func (e *Election) Key() string { return e.leaderKey }
+
+// Rev returns the leader key's creation revision, if elected.
+func (e *Election) Rev() int64 { return e.leaderRev }
+
+// Header is the response header from the last successful election proposal.
+func (e *Election) Header() *pb.ResponseHeader { return e.hdr }
diff --git a/vendor/github.com/coreos/etcd/clientv3/concurrency/key.go b/vendor/github.com/coreos/etcd/clientv3/concurrency/key.go
new file mode 100644
index 000000000..4b6e399bd
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/concurrency/key.go
@@ -0,0 +1,65 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package concurrency
+
+import (
+	"context"
+	"fmt"
+
+	v3 "github.com/coreos/etcd/clientv3"
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+	"github.com/coreos/etcd/mvcc/mvccpb"
+)
+
+func waitDelete(ctx context.Context, client *v3.Client, key string, rev int64) error {
+	cctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	var wr v3.WatchResponse
+	wch := client.Watch(cctx, key, v3.WithRev(rev))
+	for wr = range wch {
+		for _, ev := range wr.Events {
+			if ev.Type == mvccpb.DELETE {
+				return nil
+			}
+		}
+	}
+	if err := wr.Err(); err != nil {
+		return err
+	}
+	if err := ctx.Err(); err != nil {
+		return err
+	}
+	return fmt.Errorf("lost watcher waiting for delete")
+}
+
+// waitDeletes efficiently waits until all keys matching the prefix and no greater
+// than the create revision.
+func waitDeletes(ctx context.Context, client *v3.Client, pfx string, maxCreateRev int64) (*pb.ResponseHeader, error) {
+	getOpts := append(v3.WithLastCreate(), v3.WithMaxCreateRev(maxCreateRev))
+	for {
+		resp, err := client.Get(ctx, pfx, getOpts...)
+		if err != nil {
+			return nil, err
+		}
+		if len(resp.Kvs) == 0 {
+			return resp.Header, nil
+		}
+		lastKey := string(resp.Kvs[0].Key)
+		if err = waitDelete(ctx, client, lastKey, resp.Header.Revision); err != nil {
+			return nil, err
+		}
+	}
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/concurrency/mutex.go b/vendor/github.com/coreos/etcd/clientv3/concurrency/mutex.go
new file mode 100644
index 000000000..dac9ba5a2
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/concurrency/mutex.go
@@ -0,0 +1,118 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package concurrency
+
+import (
+	"context"
+	"fmt"
+	"sync"
+
+	v3 "github.com/coreos/etcd/clientv3"
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+)
+
+// Mutex implements the sync Locker interface with etcd
+type Mutex struct {
+	s *Session
+
+	pfx   string
+	myKey string
+	myRev int64
+	hdr   *pb.ResponseHeader
+}
+
+func NewMutex(s *Session, pfx string) *Mutex {
+	return &Mutex{s, pfx + "/", "", -1, nil}
+}
+
+// Lock locks the mutex with a cancelable context. If the context is canceled
+// while trying to acquire the lock, the mutex tries to clean its stale lock entry.
+func (m *Mutex) Lock(ctx context.Context) error {
+	s := m.s
+	client := m.s.Client()
+
+	m.myKey = fmt.Sprintf("%s%x", m.pfx, s.Lease())
+	cmp := v3.Compare(v3.CreateRevision(m.myKey), "=", 0)
+	// put self in lock waiters via myKey; oldest waiter holds lock
+	put := v3.OpPut(m.myKey, "", v3.WithLease(s.Lease()))
+	// reuse key in case this session already holds the lock
+	get := v3.OpGet(m.myKey)
+	// fetch current holder to complete uncontended path with only one RPC
+	getOwner := v3.OpGet(m.pfx, v3.WithFirstCreate()...)
+	resp, err := client.Txn(ctx).If(cmp).Then(put, getOwner).Else(get, getOwner).Commit()
+	if err != nil {
+		return err
+	}
+	m.myRev = resp.Header.Revision
+	if !resp.Succeeded {
+		m.myRev = resp.Responses[0].GetResponseRange().Kvs[0].CreateRevision
+	}
+	// if no key on prefix / the minimum rev is key, already hold the lock
+	ownerKey := resp.Responses[1].GetResponseRange().Kvs
+	if len(ownerKey) == 0 || ownerKey[0].CreateRevision == m.myRev {
+		m.hdr = resp.Header
+		return nil
+	}
+
+	// wait for deletion revisions prior to myKey
+	hdr, werr := waitDeletes(ctx, client, m.pfx, m.myRev-1)
+	// release lock key if cancelled
+	select {
+	case <-ctx.Done():
+		m.Unlock(client.Ctx())
+	default:
+		m.hdr = hdr
+	}
+	return werr
+}
+
+func (m *Mutex) Unlock(ctx context.Context) error {
+	client := m.s.Client()
+	if _, err := client.Delete(ctx, m.myKey); err != nil {
+		return err
+	}
+	m.myKey = "\x00"
+	m.myRev = -1
+	return nil
+}
+
+func (m *Mutex) IsOwner() v3.Cmp {
+	return v3.Compare(v3.CreateRevision(m.myKey), "=", m.myRev)
+}
+
+func (m *Mutex) Key() string { return m.myKey }
+
+// Header is the response header received from etcd on acquiring the lock.
+func (m *Mutex) Header() *pb.ResponseHeader { return m.hdr }
+
+type lockerMutex struct{ *Mutex }
+
+func (lm *lockerMutex) Lock() {
+	client := lm.s.Client()
+	if err := lm.Mutex.Lock(client.Ctx()); err != nil {
+		panic(err)
+	}
+}
+func (lm *lockerMutex) Unlock() {
+	client := lm.s.Client()
+	if err := lm.Mutex.Unlock(client.Ctx()); err != nil {
+		panic(err)
+	}
+}
+
+// NewLocker creates a sync.Locker backed by an etcd mutex.
+func NewLocker(s *Session, pfx string) sync.Locker {
+	return &lockerMutex{NewMutex(s, pfx)}
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/concurrency/session.go b/vendor/github.com/coreos/etcd/clientv3/concurrency/session.go
new file mode 100644
index 000000000..c399d64a6
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/concurrency/session.go
@@ -0,0 +1,141 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package concurrency
+
+import (
+	"context"
+	"time"
+
+	v3 "github.com/coreos/etcd/clientv3"
+)
+
+const defaultSessionTTL = 60
+
+// Session represents a lease kept alive for the lifetime of a client.
+// Fault-tolerant applications may use sessions to reason about liveness.
+type Session struct {
+	client *v3.Client
+	opts   *sessionOptions
+	id     v3.LeaseID
+
+	cancel context.CancelFunc
+	donec  <-chan struct{}
+}
+
+// NewSession gets the leased session for a client.
+func NewSession(client *v3.Client, opts ...SessionOption) (*Session, error) {
+	ops := &sessionOptions{ttl: defaultSessionTTL, ctx: client.Ctx()}
+	for _, opt := range opts {
+		opt(ops)
+	}
+
+	id := ops.leaseID
+	if id == v3.NoLease {
+		resp, err := client.Grant(ops.ctx, int64(ops.ttl))
+		if err != nil {
+			return nil, err
+		}
+		id = v3.LeaseID(resp.ID)
+	}
+
+	ctx, cancel := context.WithCancel(ops.ctx)
+	keepAlive, err := client.KeepAlive(ctx, id)
+	if err != nil || keepAlive == nil {
+		cancel()
+		return nil, err
+	}
+
+	donec := make(chan struct{})
+	s := &Session{client: client, opts: ops, id: id, cancel: cancel, donec: donec}
+
+	// keep the lease alive until client error or cancelled context
+	go func() {
+		defer close(donec)
+		for range keepAlive {
+			// eat messages until keep alive channel closes
+		}
+	}()
+
+	return s, nil
+}
+
+// Client is the etcd client that is attached to the session.
+func (s *Session) Client() *v3.Client {
+	return s.client
+}
+
+// Lease is the lease ID for keys bound to the session.
+func (s *Session) Lease() v3.LeaseID { return s.id }
+
+// Done returns a channel that closes when the lease is orphaned, expires, or
+// is otherwise no longer being refreshed.
+func (s *Session) Done() <-chan struct{} { return s.donec }
+
+// Orphan ends the refresh for the session lease. This is useful
+// in case the state of the client connection is indeterminate (revoke
+// would fail) or when transferring lease ownership.
+func (s *Session) Orphan() {
+	s.cancel()
+	<-s.donec
+}
+
+// Close orphans the session and revokes the session lease.
+func (s *Session) Close() error {
+	s.Orphan()
+	// if revoke takes longer than the ttl, lease is expired anyway
+	ctx, cancel := context.WithTimeout(s.opts.ctx, time.Duration(s.opts.ttl)*time.Second)
+	_, err := s.client.Revoke(ctx, s.id)
+	cancel()
+	return err
+}
+
+type sessionOptions struct {
+	ttl     int
+	leaseID v3.LeaseID
+	ctx     context.Context
+}
+
+// SessionOption configures Session.
+type SessionOption func(*sessionOptions)
+
+// WithTTL configures the session's TTL in seconds.
+// If TTL is <= 0, the default 60 seconds TTL will be used.
+func WithTTL(ttl int) SessionOption {
+	return func(so *sessionOptions) {
+		if ttl > 0 {
+			so.ttl = ttl
+		}
+	}
+}
+
+// WithLease specifies the existing leaseID to be used for the session.
+// This is useful in process restart scenario, for example, to reclaim
+// leadership from an election prior to restart.
+func WithLease(leaseID v3.LeaseID) SessionOption {
+	return func(so *sessionOptions) {
+		so.leaseID = leaseID
+	}
+}
+
+// WithContext assigns a context to the session instead of defaulting to
+// using the client context. This is useful for canceling NewSession and
+// Close operations immediately without having to close the client. If the
+// context is canceled before Close() completes, the session's lease will be
+// abandoned and left to expire instead of being revoked.
+func WithContext(ctx context.Context) SessionOption {
+	return func(so *sessionOptions) {
+		so.ctx = ctx
+	}
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/concurrency/stm.go b/vendor/github.com/coreos/etcd/clientv3/concurrency/stm.go
new file mode 100644
index 000000000..d11023ebe
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/concurrency/stm.go
@@ -0,0 +1,387 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package concurrency
+
+import (
+	"context"
+	"math"
+
+	v3 "github.com/coreos/etcd/clientv3"
+)
+
+// STM is an interface for software transactional memory.
+type STM interface {
+	// Get returns the value for a key and inserts the key in the txn's read set.
+	// If Get fails, it aborts the transaction with an error, never returning.
+	Get(key ...string) string
+	// Put adds a value for a key to the write set.
+	Put(key, val string, opts ...v3.OpOption)
+	// Rev returns the revision of a key in the read set.
+	Rev(key string) int64
+	// Del deletes a key.
+	Del(key string)
+
+	// commit attempts to apply the txn's changes to the server.
+	commit() *v3.TxnResponse
+	reset()
+}
+
+// Isolation is an enumeration of transactional isolation levels which
+// describes how transactions should interfere and conflict.
+type Isolation int
+
+const (
+	// SerializableSnapshot provides serializable isolation and also checks
+	// for write conflicts.
+	SerializableSnapshot Isolation = iota
+	// Serializable reads within the same transaction attempt return data
+	// from the at the revision of the first read.
+	Serializable
+	// RepeatableReads reads within the same transaction attempt always
+	// return the same data.
+	RepeatableReads
+	// ReadCommitted reads keys from any committed revision.
+	ReadCommitted
+)
+
+// stmError safely passes STM errors through panic to the STM error channel.
+type stmError struct{ err error }
+
+type stmOptions struct {
+	iso      Isolation
+	ctx      context.Context
+	prefetch []string
+}
+
+type stmOption func(*stmOptions)
+
+// WithIsolation specifies the transaction isolation level.
+func WithIsolation(lvl Isolation) stmOption {
+	return func(so *stmOptions) { so.iso = lvl }
+}
+
+// WithAbortContext specifies the context for permanently aborting the transaction.
+func WithAbortContext(ctx context.Context) stmOption {
+	return func(so *stmOptions) { so.ctx = ctx }
+}
+
+// WithPrefetch is a hint to prefetch a list of keys before trying to apply.
+// If an STM transaction will unconditionally fetch a set of keys, prefetching
+// those keys will save the round-trip cost from requesting each key one by one
+// with Get().
+func WithPrefetch(keys ...string) stmOption {
+	return func(so *stmOptions) { so.prefetch = append(so.prefetch, keys...) }
+}
+
+// NewSTM initiates a new STM instance, using serializable snapshot isolation by default.
+func NewSTM(c *v3.Client, apply func(STM) error, so ...stmOption) (*v3.TxnResponse, error) {
+	opts := &stmOptions{ctx: c.Ctx()}
+	for _, f := range so {
+		f(opts)
+	}
+	if len(opts.prefetch) != 0 {
+		f := apply
+		apply = func(s STM) error {
+			s.Get(opts.prefetch...)
+			return f(s)
+		}
+	}
+	return runSTM(mkSTM(c, opts), apply)
+}
+
+func mkSTM(c *v3.Client, opts *stmOptions) STM {
+	switch opts.iso {
+	case SerializableSnapshot:
+		s := &stmSerializable{
+			stm:      stm{client: c, ctx: opts.ctx},
+			prefetch: make(map[string]*v3.GetResponse),
+		}
+		s.conflicts = func() []v3.Cmp {
+			return append(s.rset.cmps(), s.wset.cmps(s.rset.first()+1)...)
+		}
+		return s
+	case Serializable:
+		s := &stmSerializable{
+			stm:      stm{client: c, ctx: opts.ctx},
+			prefetch: make(map[string]*v3.GetResponse),
+		}
+		s.conflicts = func() []v3.Cmp { return s.rset.cmps() }
+		return s
+	case RepeatableReads:
+		s := &stm{client: c, ctx: opts.ctx, getOpts: []v3.OpOption{v3.WithSerializable()}}
+		s.conflicts = func() []v3.Cmp { return s.rset.cmps() }
+		return s
+	case ReadCommitted:
+		s := &stm{client: c, ctx: opts.ctx, getOpts: []v3.OpOption{v3.WithSerializable()}}
+		s.conflicts = func() []v3.Cmp { return nil }
+		return s
+	default:
+		panic("unsupported stm")
+	}
+}
+
+type stmResponse struct {
+	resp *v3.TxnResponse
+	err  error
+}
+
+func runSTM(s STM, apply func(STM) error) (*v3.TxnResponse, error) {
+	outc := make(chan stmResponse, 1)
+	go func() {
+		defer func() {
+			if r := recover(); r != nil {
+				e, ok := r.(stmError)
+				if !ok {
+					// client apply panicked
+					panic(r)
+				}
+				outc <- stmResponse{nil, e.err}
+			}
+		}()
+		var out stmResponse
+		for {
+			s.reset()
+			if out.err = apply(s); out.err != nil {
+				break
+			}
+			if out.resp = s.commit(); out.resp != nil {
+				break
+			}
+		}
+		outc <- out
+	}()
+	r := <-outc
+	return r.resp, r.err
+}
+
+// stm implements repeatable-read software transactional memory over etcd
+type stm struct {
+	client *v3.Client
+	ctx    context.Context
+	// rset holds read key values and revisions
+	rset readSet
+	// wset holds overwritten keys and their values
+	wset writeSet
+	// getOpts are the opts used for gets
+	getOpts []v3.OpOption
+	// conflicts computes the current conflicts on the txn
+	conflicts func() []v3.Cmp
+}
+
+type stmPut struct {
+	val string
+	op  v3.Op
+}
+
+type readSet map[string]*v3.GetResponse
+
+func (rs readSet) add(keys []string, txnresp *v3.TxnResponse) {
+	for i, resp := range txnresp.Responses {
+		rs[keys[i]] = (*v3.GetResponse)(resp.GetResponseRange())
+	}
+}
+
+// first returns the store revision from the first fetch
+func (rs readSet) first() int64 {
+	ret := int64(math.MaxInt64 - 1)
+	for _, resp := range rs {
+		if rev := resp.Header.Revision; rev < ret {
+			ret = rev
+		}
+	}
+	return ret
+}
+
+// cmps guards the txn from updates to read set
+func (rs readSet) cmps() []v3.Cmp {
+	cmps := make([]v3.Cmp, 0, len(rs))
+	for k, rk := range rs {
+		cmps = append(cmps, isKeyCurrent(k, rk))
+	}
+	return cmps
+}
+
+type writeSet map[string]stmPut
+
+func (ws writeSet) get(keys ...string) *stmPut {
+	for _, key := range keys {
+		if wv, ok := ws[key]; ok {
+			return &wv
+		}
+	}
+	return nil
+}
+
+// cmps returns a cmp list testing no writes have happened past rev
+func (ws writeSet) cmps(rev int64) []v3.Cmp {
+	cmps := make([]v3.Cmp, 0, len(ws))
+	for key := range ws {
+		cmps = append(cmps, v3.Compare(v3.ModRevision(key), "<", rev))
+	}
+	return cmps
+}
+
+// puts is the list of ops for all pending writes
+func (ws writeSet) puts() []v3.Op {
+	puts := make([]v3.Op, 0, len(ws))
+	for _, v := range ws {
+		puts = append(puts, v.op)
+	}
+	return puts
+}
+
+func (s *stm) Get(keys ...string) string {
+	if wv := s.wset.get(keys...); wv != nil {
+		return wv.val
+	}
+	return respToValue(s.fetch(keys...))
+}
+
+func (s *stm) Put(key, val string, opts ...v3.OpOption) {
+	s.wset[key] = stmPut{val, v3.OpPut(key, val, opts...)}
+}
+
+func (s *stm) Del(key string) { s.wset[key] = stmPut{"", v3.OpDelete(key)} }
+
+func (s *stm) Rev(key string) int64 {
+	if resp := s.fetch(key); resp != nil && len(resp.Kvs) != 0 {
+		return resp.Kvs[0].ModRevision
+	}
+	return 0
+}
+
+func (s *stm) commit() *v3.TxnResponse {
+	txnresp, err := s.client.Txn(s.ctx).If(s.conflicts()...).Then(s.wset.puts()...).Commit()
+	if err != nil {
+		panic(stmError{err})
+	}
+	if txnresp.Succeeded {
+		return txnresp
+	}
+	return nil
+}
+
+func (s *stm) fetch(keys ...string) *v3.GetResponse {
+	if len(keys) == 0 {
+		return nil
+	}
+	ops := make([]v3.Op, len(keys))
+	for i, key := range keys {
+		if resp, ok := s.rset[key]; ok {
+			return resp
+		}
+		ops[i] = v3.OpGet(key, s.getOpts...)
+	}
+	txnresp, err := s.client.Txn(s.ctx).Then(ops...).Commit()
+	if err != nil {
+		panic(stmError{err})
+	}
+	s.rset.add(keys, txnresp)
+	return (*v3.GetResponse)(txnresp.Responses[0].GetResponseRange())
+}
+
+func (s *stm) reset() {
+	s.rset = make(map[string]*v3.GetResponse)
+	s.wset = make(map[string]stmPut)
+}
+
+type stmSerializable struct {
+	stm
+	prefetch map[string]*v3.GetResponse
+}
+
+func (s *stmSerializable) Get(keys ...string) string {
+	if wv := s.wset.get(keys...); wv != nil {
+		return wv.val
+	}
+	firstRead := len(s.rset) == 0
+	for _, key := range keys {
+		if resp, ok := s.prefetch[key]; ok {
+			delete(s.prefetch, key)
+			s.rset[key] = resp
+		}
+	}
+	resp := s.stm.fetch(keys...)
+	if firstRead {
+		// txn's base revision is defined by the first read
+		s.getOpts = []v3.OpOption{
+			v3.WithRev(resp.Header.Revision),
+			v3.WithSerializable(),
+		}
+	}
+	return respToValue(resp)
+}
+
+func (s *stmSerializable) Rev(key string) int64 {
+	s.Get(key)
+	return s.stm.Rev(key)
+}
+
+func (s *stmSerializable) gets() ([]string, []v3.Op) {
+	keys := make([]string, 0, len(s.rset))
+	ops := make([]v3.Op, 0, len(s.rset))
+	for k := range s.rset {
+		keys = append(keys, k)
+		ops = append(ops, v3.OpGet(k))
+	}
+	return keys, ops
+}
+
+func (s *stmSerializable) commit() *v3.TxnResponse {
+	keys, getops := s.gets()
+	txn := s.client.Txn(s.ctx).If(s.conflicts()...).Then(s.wset.puts()...)
+	// use Else to prefetch keys in case of conflict to save a round trip
+	txnresp, err := txn.Else(getops...).Commit()
+	if err != nil {
+		panic(stmError{err})
+	}
+	if txnresp.Succeeded {
+		return txnresp
+	}
+	// load prefetch with Else data
+	s.rset.add(keys, txnresp)
+	s.prefetch = s.rset
+	s.getOpts = nil
+	return nil
+}
+
+func isKeyCurrent(k string, r *v3.GetResponse) v3.Cmp {
+	if len(r.Kvs) != 0 {
+		return v3.Compare(v3.ModRevision(k), "=", r.Kvs[0].ModRevision)
+	}
+	return v3.Compare(v3.ModRevision(k), "=", 0)
+}
+
+func respToValue(resp *v3.GetResponse) string {
+	if resp == nil || len(resp.Kvs) == 0 {
+		return ""
+	}
+	return string(resp.Kvs[0].Value)
+}
+
+// NewSTMRepeatable is deprecated.
+func NewSTMRepeatable(ctx context.Context, c *v3.Client, apply func(STM) error) (*v3.TxnResponse, error) {
+	return NewSTM(c, apply, WithAbortContext(ctx), WithIsolation(RepeatableReads))
+}
+
+// NewSTMSerializable is deprecated.
+func NewSTMSerializable(ctx context.Context, c *v3.Client, apply func(STM) error) (*v3.TxnResponse, error) {
+	return NewSTM(c, apply, WithAbortContext(ctx), WithIsolation(Serializable))
+}
+
+// NewSTMReadCommitted is deprecated.
+func NewSTMReadCommitted(ctx context.Context, c *v3.Client, apply func(STM) error) (*v3.TxnResponse, error) {
+	return NewSTM(c, apply, WithAbortContext(ctx), WithIsolation(ReadCommitted))
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/config.go b/vendor/github.com/coreos/etcd/clientv3/config.go
new file mode 100644
index 000000000..87d61cf57
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/config.go
@@ -0,0 +1,62 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import (
+	"context"
+	"crypto/tls"
+	"time"
+
+	"google.golang.org/grpc"
+)
+
+type Config struct {
+	// Endpoints is a list of URLs.
+	Endpoints []string `json:"endpoints"`
+
+	// AutoSyncInterval is the interval to update endpoints with its latest members.
+	// 0 disables auto-sync. By default auto-sync is disabled.
+	AutoSyncInterval time.Duration `json:"auto-sync-interval"`
+
+	// DialTimeout is the timeout for failing to establish a connection.
+	DialTimeout time.Duration `json:"dial-timeout"`
+
+	// DialKeepAliveTime is the time in seconds after which client pings the server to see if
+	// transport is alive.
+	DialKeepAliveTime time.Duration `json:"dial-keep-alive-time"`
+
+	// DialKeepAliveTimeout is the time in seconds that the client waits for a response for the
+	// keep-alive probe.  If the response is not received in this time, the connection is closed.
+	DialKeepAliveTimeout time.Duration `json:"dial-keep-alive-timeout"`
+
+	// TLS holds the client secure credentials, if any.
+	TLS *tls.Config
+
+	// Username is a user name for authentication.
+	Username string `json:"username"`
+
+	// Password is a password for authentication.
+	Password string `json:"password"`
+
+	// RejectOldCluster when set will refuse to create a client against an outdated cluster.
+	RejectOldCluster bool `json:"reject-old-cluster"`
+
+	// DialOptions is a list of dial options for the grpc client (e.g., for interceptors).
+	DialOptions []grpc.DialOption
+
+	// Context is the default client context; it can be used to cancel grpc dial out and
+	// other operations that do not have an explicit context.
+	Context context.Context
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/doc.go b/vendor/github.com/coreos/etcd/clientv3/doc.go
new file mode 100644
index 000000000..dacc5bb34
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/doc.go
@@ -0,0 +1,64 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package clientv3 implements the official Go etcd client for v3.
+//
+// Create client using `clientv3.New`:
+//
+//	cli, err := clientv3.New(clientv3.Config{
+//		Endpoints:   []string{"localhost:2379", "localhost:22379", "localhost:32379"},
+//		DialTimeout: 5 * time.Second,
+//	})
+//	if err != nil {
+//		// handle error!
+//	}
+//	defer cli.Close()
+//
+// Make sure to close the client after using it. If the client is not closed, the
+// connection will have leaky goroutines.
+//
+// To specify a client request timeout, wrap the context with context.WithTimeout:
+//
+//	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+//	resp, err := kvc.Put(ctx, "sample_key", "sample_value")
+//	cancel()
+//	if err != nil {
+//	    // handle error!
+//	}
+//	// use the response
+//
+// The Client has internal state (watchers and leases), so Clients should be reused instead of created as needed.
+// Clients are safe for concurrent use by multiple goroutines.
+//
+// etcd client returns 2 types of errors:
+//
+//	1. context error: canceled or deadline exceeded.
+//	2. gRPC error: see https://github.com/coreos/etcd/blob/master/etcdserver/api/v3rpc/rpctypes/error.go
+//
+// Here is the example code to handle client errors:
+//
+//	resp, err := kvc.Put(ctx, "", "")
+//	if err != nil {
+//		if err == context.Canceled {
+//			// ctx is canceled by another routine
+//		} else if err == context.DeadlineExceeded {
+//			// ctx is attached with a deadline and it exceeded
+//		} else if verr, ok := err.(*v3rpc.ErrEmptyKey); ok {
+//			// process (verr.Errors)
+//		} else {
+//			// bad cluster endpoints, which are not etcd servers
+//		}
+//	}
+//
+package clientv3
diff --git a/vendor/github.com/coreos/etcd/clientv3/health_balancer.go b/vendor/github.com/coreos/etcd/clientv3/health_balancer.go
new file mode 100644
index 000000000..8f4ba08ae
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/health_balancer.go
@@ -0,0 +1,249 @@
+// Copyright 2017 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	healthpb "google.golang.org/grpc/health/grpc_health_v1"
+	"google.golang.org/grpc/status"
+)
+
+const minHealthRetryDuration = 3 * time.Second
+const unknownService = "unknown service grpc.health.v1.Health"
+
+type healthCheckFunc func(ep string) (bool, error)
+
+// healthBalancer wraps a balancer so that it uses health checking
+// to choose its endpoints.
+type healthBalancer struct {
+	*simpleBalancer
+
+	// healthCheck checks an endpoint's health.
+	healthCheck        healthCheckFunc
+	healthCheckTimeout time.Duration
+
+	// mu protects addrs, eps, unhealthy map, and stopc.
+	mu sync.RWMutex
+
+	// addrs stores all grpc addresses associated with the balancer.
+	addrs []grpc.Address
+
+	// eps stores all client endpoints
+	eps []string
+
+	// unhealthy tracks the last unhealthy time of endpoints.
+	unhealthy map[string]time.Time
+
+	stopc    chan struct{}
+	stopOnce sync.Once
+
+	hostPort2ep map[string]string
+
+	wg sync.WaitGroup
+}
+
+func newHealthBalancer(b *simpleBalancer, timeout time.Duration, hc healthCheckFunc) *healthBalancer {
+	hb := &healthBalancer{
+		simpleBalancer: b,
+		healthCheck:    hc,
+		eps:            b.endpoints(),
+		addrs:          eps2addrs(b.endpoints()),
+		hostPort2ep:    getHostPort2ep(b.endpoints()),
+		unhealthy:      make(map[string]time.Time),
+		stopc:          make(chan struct{}),
+	}
+	if timeout < minHealthRetryDuration {
+		timeout = minHealthRetryDuration
+	}
+	hb.healthCheckTimeout = timeout
+
+	hb.wg.Add(1)
+	go func() {
+		defer hb.wg.Done()
+		hb.updateUnhealthy(timeout)
+	}()
+
+	return hb
+}
+
+func (hb *healthBalancer) Up(addr grpc.Address) func(error) {
+	f, used := hb.up(addr)
+	if !used {
+		return f
+	}
+	return func(err error) {
+		// If connected to a black hole endpoint or a killed server, the gRPC ping
+		// timeout will induce a network I/O error, and retrying until success;
+		// finding healthy endpoint on retry could take several timeouts and redials.
+		// To avoid wasting retries, gray-list unhealthy endpoints.
+		hb.hostPortError(addr.Addr, err)
+		f(err)
+	}
+}
+
+func (hb *healthBalancer) up(addr grpc.Address) (func(error), bool) {
+	if !hb.mayPin(addr) {
+		return func(err error) {}, false
+	}
+	return hb.simpleBalancer.up(addr)
+}
+
+func (hb *healthBalancer) Close() error {
+	hb.stopOnce.Do(func() { close(hb.stopc) })
+	hb.wg.Wait()
+	return hb.simpleBalancer.Close()
+}
+
+func (hb *healthBalancer) updateAddrs(eps ...string) {
+	addrs, hostPort2ep := eps2addrs(eps), getHostPort2ep(eps)
+	hb.mu.Lock()
+	hb.addrs, hb.eps, hb.hostPort2ep = addrs, eps, hostPort2ep
+	hb.unhealthy = make(map[string]time.Time)
+	hb.mu.Unlock()
+	hb.simpleBalancer.updateAddrs(eps...)
+}
+
+func (hb *healthBalancer) endpoint(host string) string {
+	hb.mu.RLock()
+	defer hb.mu.RUnlock()
+	return hb.hostPort2ep[host]
+}
+
+func (hb *healthBalancer) endpoints() []string {
+	hb.mu.RLock()
+	defer hb.mu.RUnlock()
+	return hb.eps
+}
+
+func (hb *healthBalancer) updateUnhealthy(timeout time.Duration) {
+	for {
+		select {
+		case <-time.After(timeout):
+			hb.mu.Lock()
+			for k, v := range hb.unhealthy {
+				if time.Since(v) > timeout {
+					delete(hb.unhealthy, k)
+					if logger.V(4) {
+						logger.Infof("clientv3/health-balancer: removes %q from unhealthy after %v", k, timeout)
+					}
+				}
+			}
+			hb.mu.Unlock()
+			eps := []string{}
+			for _, addr := range hb.liveAddrs() {
+				eps = append(eps, hb.endpoint(addr.Addr))
+			}
+			hb.simpleBalancer.updateAddrs(eps...)
+		case <-hb.stopc:
+			return
+		}
+	}
+}
+
+func (hb *healthBalancer) liveAddrs() []grpc.Address {
+	hb.mu.RLock()
+	defer hb.mu.RUnlock()
+	hbAddrs := hb.addrs
+	if len(hb.addrs) == 1 || len(hb.unhealthy) == 0 || len(hb.unhealthy) == len(hb.addrs) {
+		return hbAddrs
+	}
+	addrs := make([]grpc.Address, 0, len(hb.addrs)-len(hb.unhealthy))
+	for _, addr := range hb.addrs {
+		if _, unhealthy := hb.unhealthy[addr.Addr]; !unhealthy {
+			addrs = append(addrs, addr)
+		}
+	}
+	return addrs
+}
+
+func (hb *healthBalancer) hostPortError(hostPort string, err error) {
+	hb.mu.Lock()
+	if _, ok := hb.hostPort2ep[hostPort]; ok {
+		hb.unhealthy[hostPort] = time.Now()
+		if logger.V(4) {
+			logger.Infof("clientv3/health-balancer: marking %q as unhealthy (%q)", hostPort, err.Error())
+		}
+	}
+	hb.mu.Unlock()
+}
+
+func (hb *healthBalancer) mayPin(addr grpc.Address) bool {
+	hb.mu.RLock()
+	if _, ok := hb.hostPort2ep[addr.Addr]; !ok { // stale host:port
+		hb.mu.RUnlock()
+		return false
+	}
+	skip := len(hb.addrs) == 1 || len(hb.unhealthy) == 0 || len(hb.addrs) == len(hb.unhealthy)
+	failedTime, bad := hb.unhealthy[addr.Addr]
+	dur := hb.healthCheckTimeout
+	hb.mu.RUnlock()
+	if skip || !bad {
+		return true
+	}
+	// prevent isolated member's endpoint from being infinitely retried, as follows:
+	//   1. keepalive pings detects GoAway with http2.ErrCodeEnhanceYourCalm
+	//   2. balancer 'Up' unpins with grpc: failed with network I/O error
+	//   3. grpc-healthcheck still SERVING, thus retry to pin
+	// instead, return before grpc-healthcheck if failed within healthcheck timeout
+	if elapsed := time.Since(failedTime); elapsed < dur {
+		if logger.V(4) {
+			logger.Infof("clientv3/health-balancer: %q is up but not pinned (failed %v ago, require minimum %v after failure)", addr.Addr, elapsed, dur)
+		}
+		return false
+	}
+	if ok, _ := hb.healthCheck(addr.Addr); ok {
+		hb.mu.Lock()
+		delete(hb.unhealthy, addr.Addr)
+		hb.mu.Unlock()
+		if logger.V(4) {
+			logger.Infof("clientv3/health-balancer: %q is healthy (health check success)", addr.Addr)
+		}
+		return true
+	}
+	hb.mu.Lock()
+	hb.unhealthy[addr.Addr] = time.Now()
+	hb.mu.Unlock()
+	if logger.V(4) {
+		logger.Infof("clientv3/health-balancer: %q becomes unhealthy (health check failed)", addr.Addr)
+	}
+	return false
+}
+
+func grpcHealthCheck(client *Client, ep string) (bool, error) {
+	conn, err := client.dial(ep)
+	if err != nil {
+		return false, err
+	}
+	defer conn.Close()
+	cli := healthpb.NewHealthClient(conn)
+	ctx, cancel := context.WithTimeout(context.Background(), time.Second)
+	resp, err := cli.Check(ctx, &healthpb.HealthCheckRequest{})
+	cancel()
+	if err != nil {
+		if s, ok := status.FromError(err); ok && s.Code() == codes.Unavailable {
+			if s.Message() == unknownService {
+				// etcd < v3.3.0
+				return true, nil
+			}
+		}
+		return false, err
+	}
+	return resp.Status == healthpb.HealthCheckResponse_SERVING, nil
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/kv.go b/vendor/github.com/coreos/etcd/clientv3/kv.go
new file mode 100644
index 000000000..b578d9ebe
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/kv.go
@@ -0,0 +1,165 @@
+// Copyright 2015 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import (
+	"context"
+
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+)
+
+type (
+	CompactResponse pb.CompactionResponse
+	PutResponse     pb.PutResponse
+	GetResponse     pb.RangeResponse
+	DeleteResponse  pb.DeleteRangeResponse
+	TxnResponse     pb.TxnResponse
+)
+
+type KV interface {
+	// Put puts a key-value pair into etcd.
+	// Note that key,value can be plain bytes array and string is
+	// an immutable representation of that bytes array.
+	// To get a string of bytes, do string([]byte{0x10, 0x20}).
+	Put(ctx context.Context, key, val string, opts ...OpOption) (*PutResponse, error)
+
+	// Get retrieves keys.
+	// By default, Get will return the value for "key", if any.
+	// When passed WithRange(end), Get will return the keys in the range [key, end).
+	// When passed WithFromKey(), Get returns keys greater than or equal to key.
+	// When passed WithRev(rev) with rev > 0, Get retrieves keys at the given revision;
+	// if the required revision is compacted, the request will fail with ErrCompacted .
+	// When passed WithLimit(limit), the number of returned keys is bounded by limit.
+	// When passed WithSort(), the keys will be sorted.
+	Get(ctx context.Context, key string, opts ...OpOption) (*GetResponse, error)
+
+	// Delete deletes a key, or optionally using WithRange(end), [key, end).
+	Delete(ctx context.Context, key string, opts ...OpOption) (*DeleteResponse, error)
+
+	// Compact compacts etcd KV history before the given rev.
+	Compact(ctx context.Context, rev int64, opts ...CompactOption) (*CompactResponse, error)
+
+	// Do applies a single Op on KV without a transaction.
+	// Do is useful when creating arbitrary operations to be issued at a
+	// later time; the user can range over the operations, calling Do to
+	// execute them. Get/Put/Delete, on the other hand, are best suited
+	// for when the operation should be issued at the time of declaration.
+	Do(ctx context.Context, op Op) (OpResponse, error)
+
+	// Txn creates a transaction.
+	Txn(ctx context.Context) Txn
+}
+
+type OpResponse struct {
+	put *PutResponse
+	get *GetResponse
+	del *DeleteResponse
+	txn *TxnResponse
+}
+
+func (op OpResponse) Put() *PutResponse    { return op.put }
+func (op OpResponse) Get() *GetResponse    { return op.get }
+func (op OpResponse) Del() *DeleteResponse { return op.del }
+func (op OpResponse) Txn() *TxnResponse    { return op.txn }
+
+func (resp *PutResponse) OpResponse() OpResponse {
+	return OpResponse{put: resp}
+}
+func (resp *GetResponse) OpResponse() OpResponse {
+	return OpResponse{get: resp}
+}
+func (resp *DeleteResponse) OpResponse() OpResponse {
+	return OpResponse{del: resp}
+}
+func (resp *TxnResponse) OpResponse() OpResponse {
+	return OpResponse{txn: resp}
+}
+
+type kv struct {
+	remote pb.KVClient
+}
+
+func NewKV(c *Client) KV {
+	return &kv{remote: RetryKVClient(c)}
+}
+
+func NewKVFromKVClient(remote pb.KVClient) KV {
+	return &kv{remote: remote}
+}
+
+func (kv *kv) Put(ctx context.Context, key, val string, opts ...OpOption) (*PutResponse, error) {
+	r, err := kv.Do(ctx, OpPut(key, val, opts...))
+	return r.put, toErr(ctx, err)
+}
+
+func (kv *kv) Get(ctx context.Context, key string, opts ...OpOption) (*GetResponse, error) {
+	r, err := kv.Do(ctx, OpGet(key, opts...))
+	return r.get, toErr(ctx, err)
+}
+
+func (kv *kv) Delete(ctx context.Context, key string, opts ...OpOption) (*DeleteResponse, error) {
+	r, err := kv.Do(ctx, OpDelete(key, opts...))
+	return r.del, toErr(ctx, err)
+}
+
+func (kv *kv) Compact(ctx context.Context, rev int64, opts ...CompactOption) (*CompactResponse, error) {
+	resp, err := kv.remote.Compact(ctx, OpCompact(rev, opts...).toRequest())
+	if err != nil {
+		return nil, toErr(ctx, err)
+	}
+	return (*CompactResponse)(resp), err
+}
+
+func (kv *kv) Txn(ctx context.Context) Txn {
+	return &txn{
+		kv:  kv,
+		ctx: ctx,
+	}
+}
+
+func (kv *kv) Do(ctx context.Context, op Op) (OpResponse, error) {
+	var err error
+	switch op.t {
+	case tRange:
+		var resp *pb.RangeResponse
+		resp, err = kv.remote.Range(ctx, op.toRangeRequest())
+		if err == nil {
+			return OpResponse{get: (*GetResponse)(resp)}, nil
+		}
+	case tPut:
+		var resp *pb.PutResponse
+		r := &pb.PutRequest{Key: op.key, Value: op.val, Lease: int64(op.leaseID), PrevKv: op.prevKV, IgnoreValue: op.ignoreValue, IgnoreLease: op.ignoreLease}
+		resp, err = kv.remote.Put(ctx, r)
+		if err == nil {
+			return OpResponse{put: (*PutResponse)(resp)}, nil
+		}
+	case tDeleteRange:
+		var resp *pb.DeleteRangeResponse
+		r := &pb.DeleteRangeRequest{Key: op.key, RangeEnd: op.end, PrevKv: op.prevKV}
+		resp, err = kv.remote.DeleteRange(ctx, r)
+		if err == nil {
+			return OpResponse{del: (*DeleteResponse)(resp)}, nil
+		}
+	case tTxn:
+		var resp *pb.TxnResponse
+		resp, err = kv.remote.Txn(ctx, op.toTxnRequest())
+		if err == nil {
+			return OpResponse{txn: (*TxnResponse)(resp)}, nil
+		}
+	default:
+		panic("Unknown op")
+	}
+	return OpResponse{}, toErr(ctx, err)
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/lease.go b/vendor/github.com/coreos/etcd/clientv3/lease.go
new file mode 100644
index 000000000..aa9ea2d78
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/lease.go
@@ -0,0 +1,560 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import (
+	"context"
+	"sync"
+	"time"
+
+	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+
+	"google.golang.org/grpc/metadata"
+)
+
+type (
+	LeaseRevokeResponse pb.LeaseRevokeResponse
+	LeaseID             int64
+)
+
+// LeaseGrantResponse wraps the protobuf message LeaseGrantResponse.
+type LeaseGrantResponse struct {
+	*pb.ResponseHeader
+	ID    LeaseID
+	TTL   int64
+	Error string
+}
+
+// LeaseKeepAliveResponse wraps the protobuf message LeaseKeepAliveResponse.
+type LeaseKeepAliveResponse struct {
+	*pb.ResponseHeader
+	ID  LeaseID
+	TTL int64
+}
+
+// LeaseTimeToLiveResponse wraps the protobuf message LeaseTimeToLiveResponse.
+type LeaseTimeToLiveResponse struct {
+	*pb.ResponseHeader
+	ID LeaseID `json:"id"`
+
+	// TTL is the remaining TTL in seconds for the lease; the lease will expire in under TTL+1 seconds.
+	TTL int64 `json:"ttl"`
+
+	// GrantedTTL is the initial granted time in seconds upon lease creation/renewal.
+	GrantedTTL int64 `json:"granted-ttl"`
+
+	// Keys is the list of keys attached to this lease.
+	Keys [][]byte `json:"keys"`
+}
+
+// LeaseStatus represents a lease status.
+type LeaseStatus struct {
+	ID LeaseID `json:"id"`
+	// TODO: TTL int64
+}
+
+// LeaseLeasesResponse wraps the protobuf message LeaseLeasesResponse.
+type LeaseLeasesResponse struct {
+	*pb.ResponseHeader
+	Leases []LeaseStatus `json:"leases"`
+}
+
+const (
+	// defaultTTL is the assumed lease TTL used for the first keepalive
+	// deadline before the actual TTL is known to the client.
+	defaultTTL = 5 * time.Second
+	// a small buffer to store unsent lease responses.
+	leaseResponseChSize = 16
+	// NoLease is a lease ID for the absence of a lease.
+	NoLease LeaseID = 0
+
+	// retryConnWait is how long to wait before retrying request due to an error
+	retryConnWait = 500 * time.Millisecond
+)
+
+// ErrKeepAliveHalted is returned if client keep alive loop halts with an unexpected error.
+//
+// This usually means that automatic lease renewal via KeepAlive is broken, but KeepAliveOnce will still work as expected.
+type ErrKeepAliveHalted struct {
+	Reason error
+}
+
+func (e ErrKeepAliveHalted) Error() string {
+	s := "etcdclient: leases keep alive halted"
+	if e.Reason != nil {
+		s += ": " + e.Reason.Error()
+	}
+	return s
+}
+
+type Lease interface {
+	// Grant creates a new lease.
+	Grant(ctx context.Context, ttl int64) (*LeaseGrantResponse, error)
+
+	// Revoke revokes the given lease.
+	Revoke(ctx context.Context, id LeaseID) (*LeaseRevokeResponse, error)
+
+	// TimeToLive retrieves the lease information of the given lease ID.
+	TimeToLive(ctx context.Context, id LeaseID, opts ...LeaseOption) (*LeaseTimeToLiveResponse, error)
+
+	// Leases retrieves all leases.
+	Leases(ctx context.Context) (*LeaseLeasesResponse, error)
+
+	// KeepAlive keeps the given lease alive forever.
+	KeepAlive(ctx context.Context, id LeaseID) (<-chan *LeaseKeepAliveResponse, error)
+
+	// KeepAliveOnce renews the lease once. In most of the cases, KeepAlive
+	// should be used instead of KeepAliveOnce.
+	KeepAliveOnce(ctx context.Context, id LeaseID) (*LeaseKeepAliveResponse, error)
+
+	// Close releases all resources Lease keeps for efficient communication
+	// with the etcd server.
+	Close() error
+}
+
+type lessor struct {
+	mu sync.Mutex // guards all fields
+
+	// donec is closed and loopErr is set when recvKeepAliveLoop stops
+	donec   chan struct{}
+	loopErr error
+
+	remote pb.LeaseClient
+
+	stream       pb.Lease_LeaseKeepAliveClient
+	streamCancel context.CancelFunc
+
+	stopCtx    context.Context
+	stopCancel context.CancelFunc
+
+	keepAlives map[LeaseID]*keepAlive
+
+	// firstKeepAliveTimeout is the timeout for the first keepalive request
+	// before the actual TTL is known to the lease client
+	firstKeepAliveTimeout time.Duration
+
+	// firstKeepAliveOnce ensures stream starts after first KeepAlive call.
+	firstKeepAliveOnce sync.Once
+}
+
+// keepAlive multiplexes a keepalive for a lease over multiple channels
+type keepAlive struct {
+	chs  []chan<- *LeaseKeepAliveResponse
+	ctxs []context.Context
+	// deadline is the time the keep alive channels close if no response
+	deadline time.Time
+	// nextKeepAlive is when to send the next keep alive message
+	nextKeepAlive time.Time
+	// donec is closed on lease revoke, expiration, or cancel.
+	donec chan struct{}
+}
+
+func NewLease(c *Client) Lease {
+	return NewLeaseFromLeaseClient(RetryLeaseClient(c), c.cfg.DialTimeout+time.Second)
+}
+
+func NewLeaseFromLeaseClient(remote pb.LeaseClient, keepAliveTimeout time.Duration) Lease {
+	l := &lessor{
+		donec:                 make(chan struct{}),
+		keepAlives:            make(map[LeaseID]*keepAlive),
+		remote:                remote,
+		firstKeepAliveTimeout: keepAliveTimeout,
+	}
+	if l.firstKeepAliveTimeout == time.Second {
+		l.firstKeepAliveTimeout = defaultTTL
+	}
+	reqLeaderCtx := WithRequireLeader(context.Background())
+	l.stopCtx, l.stopCancel = context.WithCancel(reqLeaderCtx)
+	return l
+}
+
+func (l *lessor) Grant(ctx context.Context, ttl int64) (*LeaseGrantResponse, error) {
+	r := &pb.LeaseGrantRequest{TTL: ttl}
+	resp, err := l.remote.LeaseGrant(ctx, r)
+	if err == nil {
+		gresp := &LeaseGrantResponse{
+			ResponseHeader: resp.GetHeader(),
+			ID:             LeaseID(resp.ID),
+			TTL:            resp.TTL,
+			Error:          resp.Error,
+		}
+		return gresp, nil
+	}
+	return nil, toErr(ctx, err)
+}
+
+func (l *lessor) Revoke(ctx context.Context, id LeaseID) (*LeaseRevokeResponse, error) {
+	r := &pb.LeaseRevokeRequest{ID: int64(id)}
+	resp, err := l.remote.LeaseRevoke(ctx, r)
+	if err == nil {
+		return (*LeaseRevokeResponse)(resp), nil
+	}
+	return nil, toErr(ctx, err)
+}
+
+func (l *lessor) TimeToLive(ctx context.Context, id LeaseID, opts ...LeaseOption) (*LeaseTimeToLiveResponse, error) {
+	r := toLeaseTimeToLiveRequest(id, opts...)
+	resp, err := l.remote.LeaseTimeToLive(ctx, r)
+	if err == nil {
+		gresp := &LeaseTimeToLiveResponse{
+			ResponseHeader: resp.GetHeader(),
+			ID:             LeaseID(resp.ID),
+			TTL:            resp.TTL,
+			GrantedTTL:     resp.GrantedTTL,
+			Keys:           resp.Keys,
+		}
+		return gresp, nil
+	}
+	return nil, toErr(ctx, err)
+}
+
+func (l *lessor) Leases(ctx context.Context) (*LeaseLeasesResponse, error) {
+	resp, err := l.remote.LeaseLeases(ctx, &pb.LeaseLeasesRequest{})
+	if err == nil {
+		leases := make([]LeaseStatus, len(resp.Leases))
+		for i := range resp.Leases {
+			leases[i] = LeaseStatus{ID: LeaseID(resp.Leases[i].ID)}
+		}
+		return &LeaseLeasesResponse{ResponseHeader: resp.GetHeader(), Leases: leases}, nil
+	}
+	return nil, toErr(ctx, err)
+}
+
+func (l *lessor) KeepAlive(ctx context.Context, id LeaseID) (<-chan *LeaseKeepAliveResponse, error) {
+	ch := make(chan *LeaseKeepAliveResponse, leaseResponseChSize)
+
+	l.mu.Lock()
+	// ensure that recvKeepAliveLoop is still running
+	select {
+	case <-l.donec:
+		err := l.loopErr
+		l.mu.Unlock()
+		close(ch)
+		return ch, ErrKeepAliveHalted{Reason: err}
+	default:
+	}
+	ka, ok := l.keepAlives[id]
+	if !ok {
+		// create fresh keep alive
+		ka = &keepAlive{
+			chs:           []chan<- *LeaseKeepAliveResponse{ch},
+			ctxs:          []context.Context{ctx},
+			deadline:      time.Now().Add(l.firstKeepAliveTimeout),
+			nextKeepAlive: time.Now(),
+			donec:         make(chan struct{}),
+		}
+		l.keepAlives[id] = ka
+	} else {
+		// add channel and context to existing keep alive
+		ka.ctxs = append(ka.ctxs, ctx)
+		ka.chs = append(ka.chs, ch)
+	}
+	l.mu.Unlock()
+
+	go l.keepAliveCtxCloser(id, ctx, ka.donec)
+	l.firstKeepAliveOnce.Do(func() {
+		go l.recvKeepAliveLoop()
+		go l.deadlineLoop()
+	})
+
+	return ch, nil
+}
+
+func (l *lessor) KeepAliveOnce(ctx context.Context, id LeaseID) (*LeaseKeepAliveResponse, error) {
+	for {
+		resp, err := l.keepAliveOnce(ctx, id)
+		if err == nil {
+			if resp.TTL <= 0 {
+				err = rpctypes.ErrLeaseNotFound
+			}
+			return resp, err
+		}
+		if isHaltErr(ctx, err) {
+			return nil, toErr(ctx, err)
+		}
+	}
+}
+
+func (l *lessor) Close() error {
+	l.stopCancel()
+	// close for synchronous teardown if stream goroutines never launched
+	l.firstKeepAliveOnce.Do(func() { close(l.donec) })
+	<-l.donec
+	return nil
+}
+
+func (l *lessor) keepAliveCtxCloser(id LeaseID, ctx context.Context, donec <-chan struct{}) {
+	select {
+	case <-donec:
+		return
+	case <-l.donec:
+		return
+	case <-ctx.Done():
+	}
+
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	ka, ok := l.keepAlives[id]
+	if !ok {
+		return
+	}
+
+	// close channel and remove context if still associated with keep alive
+	for i, c := range ka.ctxs {
+		if c == ctx {
+			close(ka.chs[i])
+			ka.ctxs = append(ka.ctxs[:i], ka.ctxs[i+1:]...)
+			ka.chs = append(ka.chs[:i], ka.chs[i+1:]...)
+			break
+		}
+	}
+	// remove if no one more listeners
+	if len(ka.chs) == 0 {
+		delete(l.keepAlives, id)
+	}
+}
+
+// closeRequireLeader scans keepAlives for ctxs that have require leader
+// and closes the associated channels.
+func (l *lessor) closeRequireLeader() {
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	for _, ka := range l.keepAlives {
+		reqIdxs := 0
+		// find all required leader channels, close, mark as nil
+		for i, ctx := range ka.ctxs {
+			md, ok := metadata.FromOutgoingContext(ctx)
+			if !ok {
+				continue
+			}
+			ks := md[rpctypes.MetadataRequireLeaderKey]
+			if len(ks) < 1 || ks[0] != rpctypes.MetadataHasLeader {
+				continue
+			}
+			close(ka.chs[i])
+			ka.chs[i] = nil
+			reqIdxs++
+		}
+		if reqIdxs == 0 {
+			continue
+		}
+		// remove all channels that required a leader from keepalive
+		newChs := make([]chan<- *LeaseKeepAliveResponse, len(ka.chs)-reqIdxs)
+		newCtxs := make([]context.Context, len(newChs))
+		newIdx := 0
+		for i := range ka.chs {
+			if ka.chs[i] == nil {
+				continue
+			}
+			newChs[newIdx], newCtxs[newIdx] = ka.chs[i], ka.ctxs[newIdx]
+			newIdx++
+		}
+		ka.chs, ka.ctxs = newChs, newCtxs
+	}
+}
+
+func (l *lessor) keepAliveOnce(ctx context.Context, id LeaseID) (*LeaseKeepAliveResponse, error) {
+	cctx, cancel := context.WithCancel(ctx)
+	defer cancel()
+
+	stream, err := l.remote.LeaseKeepAlive(cctx)
+	if err != nil {
+		return nil, toErr(ctx, err)
+	}
+
+	err = stream.Send(&pb.LeaseKeepAliveRequest{ID: int64(id)})
+	if err != nil {
+		return nil, toErr(ctx, err)
+	}
+
+	resp, rerr := stream.Recv()
+	if rerr != nil {
+		return nil, toErr(ctx, rerr)
+	}
+
+	karesp := &LeaseKeepAliveResponse{
+		ResponseHeader: resp.GetHeader(),
+		ID:             LeaseID(resp.ID),
+		TTL:            resp.TTL,
+	}
+	return karesp, nil
+}
+
+func (l *lessor) recvKeepAliveLoop() (gerr error) {
+	defer func() {
+		l.mu.Lock()
+		close(l.donec)
+		l.loopErr = gerr
+		for _, ka := range l.keepAlives {
+			ka.close()
+		}
+		l.keepAlives = make(map[LeaseID]*keepAlive)
+		l.mu.Unlock()
+	}()
+
+	for {
+		stream, err := l.resetRecv()
+		if err != nil {
+			if canceledByCaller(l.stopCtx, err) {
+				return err
+			}
+		} else {
+			for {
+				resp, err := stream.Recv()
+				if err != nil {
+					if canceledByCaller(l.stopCtx, err) {
+						return err
+					}
+
+					if toErr(l.stopCtx, err) == rpctypes.ErrNoLeader {
+						l.closeRequireLeader()
+					}
+					break
+				}
+
+				l.recvKeepAlive(resp)
+			}
+		}
+
+		select {
+		case <-time.After(retryConnWait):
+			continue
+		case <-l.stopCtx.Done():
+			return l.stopCtx.Err()
+		}
+	}
+}
+
+// resetRecv opens a new lease stream and starts sending keep alive requests.
+func (l *lessor) resetRecv() (pb.Lease_LeaseKeepAliveClient, error) {
+	sctx, cancel := context.WithCancel(l.stopCtx)
+	stream, err := l.remote.LeaseKeepAlive(sctx)
+	if err != nil {
+		cancel()
+		return nil, err
+	}
+
+	l.mu.Lock()
+	defer l.mu.Unlock()
+	if l.stream != nil && l.streamCancel != nil {
+		l.streamCancel()
+	}
+
+	l.streamCancel = cancel
+	l.stream = stream
+
+	go l.sendKeepAliveLoop(stream)
+	return stream, nil
+}
+
+// recvKeepAlive updates a lease based on its LeaseKeepAliveResponse
+func (l *lessor) recvKeepAlive(resp *pb.LeaseKeepAliveResponse) {
+	karesp := &LeaseKeepAliveResponse{
+		ResponseHeader: resp.GetHeader(),
+		ID:             LeaseID(resp.ID),
+		TTL:            resp.TTL,
+	}
+
+	l.mu.Lock()
+	defer l.mu.Unlock()
+
+	ka, ok := l.keepAlives[karesp.ID]
+	if !ok {
+		return
+	}
+
+	if karesp.TTL <= 0 {
+		// lease expired; close all keep alive channels
+		delete(l.keepAlives, karesp.ID)
+		ka.close()
+		return
+	}
+
+	// send update to all channels
+	nextKeepAlive := time.Now().Add((time.Duration(karesp.TTL) * time.Second) / 3.0)
+	ka.deadline = time.Now().Add(time.Duration(karesp.TTL) * time.Second)
+	for _, ch := range ka.chs {
+		select {
+		case ch <- karesp:
+			ka.nextKeepAlive = nextKeepAlive
+		default:
+		}
+	}
+}
+
+// deadlineLoop reaps any keep alive channels that have not received a response
+// within the lease TTL
+func (l *lessor) deadlineLoop() {
+	for {
+		select {
+		case <-time.After(time.Second):
+		case <-l.donec:
+			return
+		}
+		now := time.Now()
+		l.mu.Lock()
+		for id, ka := range l.keepAlives {
+			if ka.deadline.Before(now) {
+				// waited too long for response; lease may be expired
+				ka.close()
+				delete(l.keepAlives, id)
+			}
+		}
+		l.mu.Unlock()
+	}
+}
+
+// sendKeepAliveLoop sends keep alive requests for the lifetime of the given stream.
+func (l *lessor) sendKeepAliveLoop(stream pb.Lease_LeaseKeepAliveClient) {
+	for {
+		var tosend []LeaseID
+
+		now := time.Now()
+		l.mu.Lock()
+		for id, ka := range l.keepAlives {
+			if ka.nextKeepAlive.Before(now) {
+				tosend = append(tosend, id)
+			}
+		}
+		l.mu.Unlock()
+
+		for _, id := range tosend {
+			r := &pb.LeaseKeepAliveRequest{ID: int64(id)}
+			if err := stream.Send(r); err != nil {
+				// TODO do something with this error?
+				return
+			}
+		}
+
+		select {
+		case <-time.After(500 * time.Millisecond):
+		case <-stream.Context().Done():
+			return
+		case <-l.donec:
+			return
+		case <-l.stopCtx.Done():
+			return
+		}
+	}
+}
+
+func (ka *keepAlive) close() {
+	close(ka.donec)
+	for _, ch := range ka.chs {
+		close(ch)
+	}
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/logger.go b/vendor/github.com/coreos/etcd/clientv3/logger.go
new file mode 100644
index 000000000..784c395c7
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/logger.go
@@ -0,0 +1,95 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import (
+	"io/ioutil"
+	"sync"
+
+	"google.golang.org/grpc/grpclog"
+)
+
+// Logger is the logger used by client library.
+// It implements grpclog.LoggerV2 interface.
+type Logger grpclog.LoggerV2
+
+var (
+	logger settableLogger
+)
+
+type settableLogger struct {
+	l  grpclog.LoggerV2
+	mu sync.RWMutex
+}
+
+func init() {
+	// disable client side logs by default
+	logger.mu.Lock()
+	logger.l = grpclog.NewLoggerV2(ioutil.Discard, ioutil.Discard, ioutil.Discard)
+
+	// logger has to override the grpclog at initialization so that
+	// any changes to the grpclog go through logger with locking
+	// instead of through SetLogger
+	//
+	// now updates only happen through settableLogger.set
+	grpclog.SetLoggerV2(&logger)
+	logger.mu.Unlock()
+}
+
+// SetLogger sets client-side Logger. By default, logs are disabled.
+func SetLogger(l Logger) {
+	logger.set(l)
+}
+
+// GetLogger returns the current logger.
+func GetLogger() Logger {
+	return logger.get()
+}
+
+func (s *settableLogger) set(l Logger) {
+	s.mu.Lock()
+	logger.l = l
+	s.mu.Unlock()
+}
+
+func (s *settableLogger) get() Logger {
+	s.mu.RLock()
+	l := logger.l
+	s.mu.RUnlock()
+	return l
+}
+
+// implement the grpclog.LoggerV2 interface
+
+func (s *settableLogger) Info(args ...interface{})                 { s.get().Info(args...) }
+func (s *settableLogger) Infof(format string, args ...interface{}) { s.get().Infof(format, args...) }
+func (s *settableLogger) Infoln(args ...interface{})               { s.get().Infoln(args...) }
+func (s *settableLogger) Warning(args ...interface{})              { s.get().Warning(args...) }
+func (s *settableLogger) Warningf(format string, args ...interface{}) {
+	s.get().Warningf(format, args...)
+}
+func (s *settableLogger) Warningln(args ...interface{}) { s.get().Warningln(args...) }
+func (s *settableLogger) Error(args ...interface{})     { s.get().Error(args...) }
+func (s *settableLogger) Errorf(format string, args ...interface{}) {
+	s.get().Errorf(format, args...)
+}
+func (s *settableLogger) Errorln(args ...interface{})               { s.get().Errorln(args...) }
+func (s *settableLogger) Fatal(args ...interface{})                 { s.get().Fatal(args...) }
+func (s *settableLogger) Fatalf(format string, args ...interface{}) { s.get().Fatalf(format, args...) }
+func (s *settableLogger) Fatalln(args ...interface{})               { s.get().Fatalln(args...) }
+func (s *settableLogger) Print(args ...interface{})                 { s.get().Info(args...) }
+func (s *settableLogger) Printf(format string, args ...interface{}) { s.get().Infof(format, args...) }
+func (s *settableLogger) Println(args ...interface{})               { s.get().Infoln(args...) }
+func (s *settableLogger) V(l int) bool                              { return s.get().V(l) }
diff --git a/vendor/github.com/coreos/etcd/clientv3/maintenance.go b/vendor/github.com/coreos/etcd/clientv3/maintenance.go
new file mode 100644
index 000000000..25abc9c91
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/maintenance.go
@@ -0,0 +1,205 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import (
+	"context"
+	"io"
+
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+)
+
+type (
+	DefragmentResponse pb.DefragmentResponse
+	AlarmResponse      pb.AlarmResponse
+	AlarmMember        pb.AlarmMember
+	StatusResponse     pb.StatusResponse
+	HashKVResponse     pb.HashKVResponse
+	MoveLeaderResponse pb.MoveLeaderResponse
+)
+
+type Maintenance interface {
+	// AlarmList gets all active alarms.
+	AlarmList(ctx context.Context) (*AlarmResponse, error)
+
+	// AlarmDisarm disarms a given alarm.
+	AlarmDisarm(ctx context.Context, m *AlarmMember) (*AlarmResponse, error)
+
+	// Defragment releases wasted space from internal fragmentation on a given etcd member.
+	// Defragment is only needed when deleting a large number of keys and want to reclaim
+	// the resources.
+	// Defragment is an expensive operation. User should avoid defragmenting multiple members
+	// at the same time.
+	// To defragment multiple members in the cluster, user need to call defragment multiple
+	// times with different endpoints.
+	Defragment(ctx context.Context, endpoint string) (*DefragmentResponse, error)
+
+	// Status gets the status of the endpoint.
+	Status(ctx context.Context, endpoint string) (*StatusResponse, error)
+
+	// HashKV returns a hash of the KV state at the time of the RPC.
+	// If revision is zero, the hash is computed on all keys. If the revision
+	// is non-zero, the hash is computed on all keys at or below the given revision.
+	HashKV(ctx context.Context, endpoint string, rev int64) (*HashKVResponse, error)
+
+	// Snapshot provides a reader for a point-in-time snapshot of etcd.
+	Snapshot(ctx context.Context) (io.ReadCloser, error)
+
+	// MoveLeader requests current leader to transfer its leadership to the transferee.
+	// Request must be made to the leader.
+	MoveLeader(ctx context.Context, transfereeID uint64) (*MoveLeaderResponse, error)
+}
+
+type maintenance struct {
+	dial   func(endpoint string) (pb.MaintenanceClient, func(), error)
+	remote pb.MaintenanceClient
+}
+
+func NewMaintenance(c *Client) Maintenance {
+	return &maintenance{
+		dial: func(endpoint string) (pb.MaintenanceClient, func(), error) {
+			conn, err := c.dial(endpoint)
+			if err != nil {
+				return nil, nil, err
+			}
+			cancel := func() { conn.Close() }
+			return RetryMaintenanceClient(c, conn), cancel, nil
+		},
+		remote: RetryMaintenanceClient(c, c.conn),
+	}
+}
+
+func NewMaintenanceFromMaintenanceClient(remote pb.MaintenanceClient) Maintenance {
+	return &maintenance{
+		dial: func(string) (pb.MaintenanceClient, func(), error) {
+			return remote, func() {}, nil
+		},
+		remote: remote,
+	}
+}
+
+func (m *maintenance) AlarmList(ctx context.Context) (*AlarmResponse, error) {
+	req := &pb.AlarmRequest{
+		Action:   pb.AlarmRequest_GET,
+		MemberID: 0,                 // all
+		Alarm:    pb.AlarmType_NONE, // all
+	}
+	resp, err := m.remote.Alarm(ctx, req)
+	if err == nil {
+		return (*AlarmResponse)(resp), nil
+	}
+	return nil, toErr(ctx, err)
+}
+
+func (m *maintenance) AlarmDisarm(ctx context.Context, am *AlarmMember) (*AlarmResponse, error) {
+	req := &pb.AlarmRequest{
+		Action:   pb.AlarmRequest_DEACTIVATE,
+		MemberID: am.MemberID,
+		Alarm:    am.Alarm,
+	}
+
+	if req.MemberID == 0 && req.Alarm == pb.AlarmType_NONE {
+		ar, err := m.AlarmList(ctx)
+		if err != nil {
+			return nil, toErr(ctx, err)
+		}
+		ret := AlarmResponse{}
+		for _, am := range ar.Alarms {
+			dresp, derr := m.AlarmDisarm(ctx, (*AlarmMember)(am))
+			if derr != nil {
+				return nil, toErr(ctx, derr)
+			}
+			ret.Alarms = append(ret.Alarms, dresp.Alarms...)
+		}
+		return &ret, nil
+	}
+
+	resp, err := m.remote.Alarm(ctx, req)
+	if err == nil {
+		return (*AlarmResponse)(resp), nil
+	}
+	return nil, toErr(ctx, err)
+}
+
+func (m *maintenance) Defragment(ctx context.Context, endpoint string) (*DefragmentResponse, error) {
+	remote, cancel, err := m.dial(endpoint)
+	if err != nil {
+		return nil, toErr(ctx, err)
+	}
+	defer cancel()
+	resp, err := remote.Defragment(ctx, &pb.DefragmentRequest{})
+	if err != nil {
+		return nil, toErr(ctx, err)
+	}
+	return (*DefragmentResponse)(resp), nil
+}
+
+func (m *maintenance) Status(ctx context.Context, endpoint string) (*StatusResponse, error) {
+	remote, cancel, err := m.dial(endpoint)
+	if err != nil {
+		return nil, toErr(ctx, err)
+	}
+	defer cancel()
+	resp, err := remote.Status(ctx, &pb.StatusRequest{})
+	if err != nil {
+		return nil, toErr(ctx, err)
+	}
+	return (*StatusResponse)(resp), nil
+}
+
+func (m *maintenance) HashKV(ctx context.Context, endpoint string, rev int64) (*HashKVResponse, error) {
+	remote, cancel, err := m.dial(endpoint)
+	if err != nil {
+		return nil, toErr(ctx, err)
+	}
+	defer cancel()
+	resp, err := remote.HashKV(ctx, &pb.HashKVRequest{Revision: rev})
+	if err != nil {
+		return nil, toErr(ctx, err)
+	}
+	return (*HashKVResponse)(resp), nil
+}
+
+func (m *maintenance) Snapshot(ctx context.Context) (io.ReadCloser, error) {
+	ss, err := m.remote.Snapshot(ctx, &pb.SnapshotRequest{})
+	if err != nil {
+		return nil, toErr(ctx, err)
+	}
+
+	pr, pw := io.Pipe()
+	go func() {
+		for {
+			resp, err := ss.Recv()
+			if err != nil {
+				pw.CloseWithError(err)
+				return
+			}
+			if resp == nil && err == nil {
+				break
+			}
+			if _, werr := pw.Write(resp.Blob); werr != nil {
+				pw.CloseWithError(werr)
+				return
+			}
+		}
+		pw.Close()
+	}()
+	return pr, nil
+}
+
+func (m *maintenance) MoveLeader(ctx context.Context, transfereeID uint64) (*MoveLeaderResponse, error) {
+	resp, err := m.remote.MoveLeader(ctx, &pb.MoveLeaderRequest{TargetID: transfereeID})
+	return (*MoveLeaderResponse)(resp), toErr(ctx, err)
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/op.go b/vendor/github.com/coreos/etcd/clientv3/op.go
new file mode 100644
index 000000000..c6ec5bf52
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/op.go
@@ -0,0 +1,513 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+
+type opType int
+
+const (
+	// A default Op has opType 0, which is invalid.
+	tRange opType = iota + 1
+	tPut
+	tDeleteRange
+	tTxn
+)
+
+var (
+	noPrefixEnd = []byte{0}
+)
+
+// Op represents an Operation that kv can execute.
+type Op struct {
+	t   opType
+	key []byte
+	end []byte
+
+	// for range
+	limit        int64
+	sort         *SortOption
+	serializable bool
+	keysOnly     bool
+	countOnly    bool
+	minModRev    int64
+	maxModRev    int64
+	minCreateRev int64
+	maxCreateRev int64
+
+	// for range, watch
+	rev int64
+
+	// for watch, put, delete
+	prevKV bool
+
+	// for put
+	ignoreValue bool
+	ignoreLease bool
+
+	// progressNotify is for progress updates.
+	progressNotify bool
+	// createdNotify is for created event
+	createdNotify bool
+	// filters for watchers
+	filterPut    bool
+	filterDelete bool
+
+	// for put
+	val     []byte
+	leaseID LeaseID
+
+	// txn
+	cmps    []Cmp
+	thenOps []Op
+	elseOps []Op
+}
+
+// accessors / mutators
+
+func (op Op) IsTxn() bool              { return op.t == tTxn }
+func (op Op) Txn() ([]Cmp, []Op, []Op) { return op.cmps, op.thenOps, op.elseOps }
+
+// KeyBytes returns the byte slice holding the Op's key.
+func (op Op) KeyBytes() []byte { return op.key }
+
+// WithKeyBytes sets the byte slice for the Op's key.
+func (op *Op) WithKeyBytes(key []byte) { op.key = key }
+
+// RangeBytes returns the byte slice holding with the Op's range end, if any.
+func (op Op) RangeBytes() []byte { return op.end }
+
+// Rev returns the requested revision, if any.
+func (op Op) Rev() int64 { return op.rev }
+
+// IsPut returns true iff the operation is a Put.
+func (op Op) IsPut() bool { return op.t == tPut }
+
+// IsGet returns true iff the operation is a Get.
+func (op Op) IsGet() bool { return op.t == tRange }
+
+// IsDelete returns true iff the operation is a Delete.
+func (op Op) IsDelete() bool { return op.t == tDeleteRange }
+
+// IsSerializable returns true if the serializable field is true.
+func (op Op) IsSerializable() bool { return op.serializable == true }
+
+// IsKeysOnly returns whether keysOnly is set.
+func (op Op) IsKeysOnly() bool { return op.keysOnly == true }
+
+// IsCountOnly returns whether countOnly is set.
+func (op Op) IsCountOnly() bool { return op.countOnly == true }
+
+// MinModRev returns the operation's minimum modify revision.
+func (op Op) MinModRev() int64 { return op.minModRev }
+
+// MaxModRev returns the operation's maximum modify revision.
+func (op Op) MaxModRev() int64 { return op.maxModRev }
+
+// MinCreateRev returns the operation's minimum create revision.
+func (op Op) MinCreateRev() int64 { return op.minCreateRev }
+
+// MaxCreateRev returns the operation's maximum create revision.
+func (op Op) MaxCreateRev() int64 { return op.maxCreateRev }
+
+// WithRangeBytes sets the byte slice for the Op's range end.
+func (op *Op) WithRangeBytes(end []byte) { op.end = end }
+
+// ValueBytes returns the byte slice holding the Op's value, if any.
+func (op Op) ValueBytes() []byte { return op.val }
+
+// WithValueBytes sets the byte slice for the Op's value.
+func (op *Op) WithValueBytes(v []byte) { op.val = v }
+
+func (op Op) toRangeRequest() *pb.RangeRequest {
+	if op.t != tRange {
+		panic("op.t != tRange")
+	}
+	r := &pb.RangeRequest{
+		Key:               op.key,
+		RangeEnd:          op.end,
+		Limit:             op.limit,
+		Revision:          op.rev,
+		Serializable:      op.serializable,
+		KeysOnly:          op.keysOnly,
+		CountOnly:         op.countOnly,
+		MinModRevision:    op.minModRev,
+		MaxModRevision:    op.maxModRev,
+		MinCreateRevision: op.minCreateRev,
+		MaxCreateRevision: op.maxCreateRev,
+	}
+	if op.sort != nil {
+		r.SortOrder = pb.RangeRequest_SortOrder(op.sort.Order)
+		r.SortTarget = pb.RangeRequest_SortTarget(op.sort.Target)
+	}
+	return r
+}
+
+func (op Op) toTxnRequest() *pb.TxnRequest {
+	thenOps := make([]*pb.RequestOp, len(op.thenOps))
+	for i, tOp := range op.thenOps {
+		thenOps[i] = tOp.toRequestOp()
+	}
+	elseOps := make([]*pb.RequestOp, len(op.elseOps))
+	for i, eOp := range op.elseOps {
+		elseOps[i] = eOp.toRequestOp()
+	}
+	cmps := make([]*pb.Compare, len(op.cmps))
+	for i := range op.cmps {
+		cmps[i] = (*pb.Compare)(&op.cmps[i])
+	}
+	return &pb.TxnRequest{Compare: cmps, Success: thenOps, Failure: elseOps}
+}
+
+func (op Op) toRequestOp() *pb.RequestOp {
+	switch op.t {
+	case tRange:
+		return &pb.RequestOp{Request: &pb.RequestOp_RequestRange{RequestRange: op.toRangeRequest()}}
+	case tPut:
+		r := &pb.PutRequest{Key: op.key, Value: op.val, Lease: int64(op.leaseID), PrevKv: op.prevKV, IgnoreValue: op.ignoreValue, IgnoreLease: op.ignoreLease}
+		return &pb.RequestOp{Request: &pb.RequestOp_RequestPut{RequestPut: r}}
+	case tDeleteRange:
+		r := &pb.DeleteRangeRequest{Key: op.key, RangeEnd: op.end, PrevKv: op.prevKV}
+		return &pb.RequestOp{Request: &pb.RequestOp_RequestDeleteRange{RequestDeleteRange: r}}
+	case tTxn:
+		return &pb.RequestOp{Request: &pb.RequestOp_RequestTxn{RequestTxn: op.toTxnRequest()}}
+	default:
+		panic("Unknown Op")
+	}
+}
+
+func (op Op) isWrite() bool {
+	if op.t == tTxn {
+		for _, tOp := range op.thenOps {
+			if tOp.isWrite() {
+				return true
+			}
+		}
+		for _, tOp := range op.elseOps {
+			if tOp.isWrite() {
+				return true
+			}
+		}
+		return false
+	}
+	return op.t != tRange
+}
+
+func OpGet(key string, opts ...OpOption) Op {
+	ret := Op{t: tRange, key: []byte(key)}
+	ret.applyOpts(opts)
+	return ret
+}
+
+func OpDelete(key string, opts ...OpOption) Op {
+	ret := Op{t: tDeleteRange, key: []byte(key)}
+	ret.applyOpts(opts)
+	switch {
+	case ret.leaseID != 0:
+		panic("unexpected lease in delete")
+	case ret.limit != 0:
+		panic("unexpected limit in delete")
+	case ret.rev != 0:
+		panic("unexpected revision in delete")
+	case ret.sort != nil:
+		panic("unexpected sort in delete")
+	case ret.serializable:
+		panic("unexpected serializable in delete")
+	case ret.countOnly:
+		panic("unexpected countOnly in delete")
+	case ret.minModRev != 0, ret.maxModRev != 0:
+		panic("unexpected mod revision filter in delete")
+	case ret.minCreateRev != 0, ret.maxCreateRev != 0:
+		panic("unexpected create revision filter in delete")
+	case ret.filterDelete, ret.filterPut:
+		panic("unexpected filter in delete")
+	case ret.createdNotify:
+		panic("unexpected createdNotify in delete")
+	}
+	return ret
+}
+
+func OpPut(key, val string, opts ...OpOption) Op {
+	ret := Op{t: tPut, key: []byte(key), val: []byte(val)}
+	ret.applyOpts(opts)
+	switch {
+	case ret.end != nil:
+		panic("unexpected range in put")
+	case ret.limit != 0:
+		panic("unexpected limit in put")
+	case ret.rev != 0:
+		panic("unexpected revision in put")
+	case ret.sort != nil:
+		panic("unexpected sort in put")
+	case ret.serializable:
+		panic("unexpected serializable in put")
+	case ret.countOnly:
+		panic("unexpected countOnly in put")
+	case ret.minModRev != 0, ret.maxModRev != 0:
+		panic("unexpected mod revision filter in put")
+	case ret.minCreateRev != 0, ret.maxCreateRev != 0:
+		panic("unexpected create revision filter in put")
+	case ret.filterDelete, ret.filterPut:
+		panic("unexpected filter in put")
+	case ret.createdNotify:
+		panic("unexpected createdNotify in put")
+	}
+	return ret
+}
+
+func OpTxn(cmps []Cmp, thenOps []Op, elseOps []Op) Op {
+	return Op{t: tTxn, cmps: cmps, thenOps: thenOps, elseOps: elseOps}
+}
+
+func opWatch(key string, opts ...OpOption) Op {
+	ret := Op{t: tRange, key: []byte(key)}
+	ret.applyOpts(opts)
+	switch {
+	case ret.leaseID != 0:
+		panic("unexpected lease in watch")
+	case ret.limit != 0:
+		panic("unexpected limit in watch")
+	case ret.sort != nil:
+		panic("unexpected sort in watch")
+	case ret.serializable:
+		panic("unexpected serializable in watch")
+	case ret.countOnly:
+		panic("unexpected countOnly in watch")
+	case ret.minModRev != 0, ret.maxModRev != 0:
+		panic("unexpected mod revision filter in watch")
+	case ret.minCreateRev != 0, ret.maxCreateRev != 0:
+		panic("unexpected create revision filter in watch")
+	}
+	return ret
+}
+
+func (op *Op) applyOpts(opts []OpOption) {
+	for _, opt := range opts {
+		opt(op)
+	}
+}
+
+// OpOption configures Operations like Get, Put, Delete.
+type OpOption func(*Op)
+
+// WithLease attaches a lease ID to a key in 'Put' request.
+func WithLease(leaseID LeaseID) OpOption {
+	return func(op *Op) { op.leaseID = leaseID }
+}
+
+// WithLimit limits the number of results to return from 'Get' request.
+// If WithLimit is given a 0 limit, it is treated as no limit.
+func WithLimit(n int64) OpOption { return func(op *Op) { op.limit = n } }
+
+// WithRev specifies the store revision for 'Get' request.
+// Or the start revision of 'Watch' request.
+func WithRev(rev int64) OpOption { return func(op *Op) { op.rev = rev } }
+
+// WithSort specifies the ordering in 'Get' request. It requires
+// 'WithRange' and/or 'WithPrefix' to be specified too.
+// 'target' specifies the target to sort by: key, version, revisions, value.
+// 'order' can be either 'SortNone', 'SortAscend', 'SortDescend'.
+func WithSort(target SortTarget, order SortOrder) OpOption {
+	return func(op *Op) {
+		if target == SortByKey && order == SortAscend {
+			// If order != SortNone, server fetches the entire key-space,
+			// and then applies the sort and limit, if provided.
+			// Since by default the server returns results sorted by keys
+			// in lexicographically ascending order, the client should ignore
+			// SortOrder if the target is SortByKey.
+			order = SortNone
+		}
+		op.sort = &SortOption{target, order}
+	}
+}
+
+// GetPrefixRangeEnd gets the range end of the prefix.
+// 'Get(foo, WithPrefix())' is equal to 'Get(foo, WithRange(GetPrefixRangeEnd(foo))'.
+func GetPrefixRangeEnd(prefix string) string {
+	return string(getPrefix([]byte(prefix)))
+}
+
+func getPrefix(key []byte) []byte {
+	end := make([]byte, len(key))
+	copy(end, key)
+	for i := len(end) - 1; i >= 0; i-- {
+		if end[i] < 0xff {
+			end[i] = end[i] + 1
+			end = end[:i+1]
+			return end
+		}
+	}
+	// next prefix does not exist (e.g., 0xffff);
+	// default to WithFromKey policy
+	return noPrefixEnd
+}
+
+// WithPrefix enables 'Get', 'Delete', or 'Watch' requests to operate
+// on the keys with matching prefix. For example, 'Get(foo, WithPrefix())'
+// can return 'foo1', 'foo2', and so on.
+func WithPrefix() OpOption {
+	return func(op *Op) {
+		if len(op.key) == 0 {
+			op.key, op.end = []byte{0}, []byte{0}
+			return
+		}
+		op.end = getPrefix(op.key)
+	}
+}
+
+// WithRange specifies the range of 'Get', 'Delete', 'Watch' requests.
+// For example, 'Get' requests with 'WithRange(end)' returns
+// the keys in the range [key, end).
+// endKey must be lexicographically greater than start key.
+func WithRange(endKey string) OpOption {
+	return func(op *Op) { op.end = []byte(endKey) }
+}
+
+// WithFromKey specifies the range of 'Get', 'Delete', 'Watch' requests
+// to be equal or greater than the key in the argument.
+func WithFromKey() OpOption { return WithRange("\x00") }
+
+// WithSerializable makes 'Get' request serializable. By default,
+// it's linearizable. Serializable requests are better for lower latency
+// requirement.
+func WithSerializable() OpOption {
+	return func(op *Op) { op.serializable = true }
+}
+
+// WithKeysOnly makes the 'Get' request return only the keys and the corresponding
+// values will be omitted.
+func WithKeysOnly() OpOption {
+	return func(op *Op) { op.keysOnly = true }
+}
+
+// WithCountOnly makes the 'Get' request return only the count of keys.
+func WithCountOnly() OpOption {
+	return func(op *Op) { op.countOnly = true }
+}
+
+// WithMinModRev filters out keys for Get with modification revisions less than the given revision.
+func WithMinModRev(rev int64) OpOption { return func(op *Op) { op.minModRev = rev } }
+
+// WithMaxModRev filters out keys for Get with modification revisions greater than the given revision.
+func WithMaxModRev(rev int64) OpOption { return func(op *Op) { op.maxModRev = rev } }
+
+// WithMinCreateRev filters out keys for Get with creation revisions less than the given revision.
+func WithMinCreateRev(rev int64) OpOption { return func(op *Op) { op.minCreateRev = rev } }
+
+// WithMaxCreateRev filters out keys for Get with creation revisions greater than the given revision.
+func WithMaxCreateRev(rev int64) OpOption { return func(op *Op) { op.maxCreateRev = rev } }
+
+// WithFirstCreate gets the key with the oldest creation revision in the request range.
+func WithFirstCreate() []OpOption { return withTop(SortByCreateRevision, SortAscend) }
+
+// WithLastCreate gets the key with the latest creation revision in the request range.
+func WithLastCreate() []OpOption { return withTop(SortByCreateRevision, SortDescend) }
+
+// WithFirstKey gets the lexically first key in the request range.
+func WithFirstKey() []OpOption { return withTop(SortByKey, SortAscend) }
+
+// WithLastKey gets the lexically last key in the request range.
+func WithLastKey() []OpOption { return withTop(SortByKey, SortDescend) }
+
+// WithFirstRev gets the key with the oldest modification revision in the request range.
+func WithFirstRev() []OpOption { return withTop(SortByModRevision, SortAscend) }
+
+// WithLastRev gets the key with the latest modification revision in the request range.
+func WithLastRev() []OpOption { return withTop(SortByModRevision, SortDescend) }
+
+// withTop gets the first key over the get's prefix given a sort order
+func withTop(target SortTarget, order SortOrder) []OpOption {
+	return []OpOption{WithPrefix(), WithSort(target, order), WithLimit(1)}
+}
+
+// WithProgressNotify makes watch server send periodic progress updates
+// every 10 minutes when there is no incoming events.
+// Progress updates have zero events in WatchResponse.
+func WithProgressNotify() OpOption {
+	return func(op *Op) {
+		op.progressNotify = true
+	}
+}
+
+// WithCreatedNotify makes watch server sends the created event.
+func WithCreatedNotify() OpOption {
+	return func(op *Op) {
+		op.createdNotify = true
+	}
+}
+
+// WithFilterPut discards PUT events from the watcher.
+func WithFilterPut() OpOption {
+	return func(op *Op) { op.filterPut = true }
+}
+
+// WithFilterDelete discards DELETE events from the watcher.
+func WithFilterDelete() OpOption {
+	return func(op *Op) { op.filterDelete = true }
+}
+
+// WithPrevKV gets the previous key-value pair before the event happens. If the previous KV is already compacted,
+// nothing will be returned.
+func WithPrevKV() OpOption {
+	return func(op *Op) {
+		op.prevKV = true
+	}
+}
+
+// WithIgnoreValue updates the key using its current value.
+// This option can not be combined with non-empty values.
+// Returns an error if the key does not exist.
+func WithIgnoreValue() OpOption {
+	return func(op *Op) {
+		op.ignoreValue = true
+	}
+}
+
+// WithIgnoreLease updates the key using its current lease.
+// This option can not be combined with WithLease.
+// Returns an error if the key does not exist.
+func WithIgnoreLease() OpOption {
+	return func(op *Op) {
+		op.ignoreLease = true
+	}
+}
+
+// LeaseOp represents an Operation that lease can execute.
+type LeaseOp struct {
+	id LeaseID
+
+	// for TimeToLive
+	attachedKeys bool
+}
+
+// LeaseOption configures lease operations.
+type LeaseOption func(*LeaseOp)
+
+func (op *LeaseOp) applyOpts(opts []LeaseOption) {
+	for _, opt := range opts {
+		opt(op)
+	}
+}
+
+// WithAttachedKeys makes TimeToLive list the keys attached to the given lease ID.
+func WithAttachedKeys() LeaseOption {
+	return func(op *LeaseOp) { op.attachedKeys = true }
+}
+
+func toLeaseTimeToLiveRequest(id LeaseID, opts ...LeaseOption) *pb.LeaseTimeToLiveRequest {
+	ret := &LeaseOp{id: id}
+	ret.applyOpts(opts)
+	return &pb.LeaseTimeToLiveRequest{ID: int64(id), Keys: ret.attachedKeys}
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/ready_wait.go b/vendor/github.com/coreos/etcd/clientv3/ready_wait.go
new file mode 100644
index 000000000..c6ef585b5
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/ready_wait.go
@@ -0,0 +1,30 @@
+// Copyright 2017 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import "context"
+
+// TODO: remove this when "FailFast=false" is fixed.
+// See https://github.com/grpc/grpc-go/issues/1532.
+func readyWait(rpcCtx, clientCtx context.Context, ready <-chan struct{}) error {
+	select {
+	case <-ready:
+		return nil
+	case <-rpcCtx.Done():
+		return rpcCtx.Err()
+	case <-clientCtx.Done():
+		return clientCtx.Err()
+	}
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/retry.go b/vendor/github.com/coreos/etcd/clientv3/retry.go
new file mode 100644
index 000000000..e6d17d032
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/retry.go
@@ -0,0 +1,495 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import (
+	"context"
+
+	"github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+type rpcFunc func(ctx context.Context) error
+type retryRPCFunc func(context.Context, rpcFunc) error
+type retryStopErrFunc func(error) bool
+
+func isRepeatableStopError(err error) bool {
+	eErr := rpctypes.Error(err)
+	// always stop retry on etcd errors
+	if serverErr, ok := eErr.(rpctypes.EtcdError); ok && serverErr.Code() != codes.Unavailable {
+		return true
+	}
+	// only retry if unavailable
+	ev, _ := status.FromError(err)
+	return ev.Code() != codes.Unavailable
+}
+
+func isNonRepeatableStopError(err error) bool {
+	ev, _ := status.FromError(err)
+	if ev.Code() != codes.Unavailable {
+		return true
+	}
+	return rpctypes.ErrorDesc(err) != "there is no address available"
+}
+
+func (c *Client) newRetryWrapper(isStop retryStopErrFunc) retryRPCFunc {
+	return func(rpcCtx context.Context, f rpcFunc) error {
+		for {
+			if err := readyWait(rpcCtx, c.ctx, c.balancer.ConnectNotify()); err != nil {
+				return err
+			}
+			pinned := c.balancer.pinned()
+			err := f(rpcCtx)
+			if err == nil {
+				return nil
+			}
+			if logger.V(4) {
+				logger.Infof("clientv3/retry: error %q on pinned endpoint %q", err.Error(), pinned)
+			}
+
+			if s, ok := status.FromError(err); ok && (s.Code() == codes.Unavailable || s.Code() == codes.DeadlineExceeded || s.Code() == codes.Internal) {
+				// mark this before endpoint switch is triggered
+				c.balancer.hostPortError(pinned, err)
+				c.balancer.next()
+				if logger.V(4) {
+					logger.Infof("clientv3/retry: switching from %q due to error %q", pinned, err.Error())
+				}
+			}
+
+			if isStop(err) {
+				return err
+			}
+		}
+	}
+}
+
+func (c *Client) newAuthRetryWrapper() retryRPCFunc {
+	return func(rpcCtx context.Context, f rpcFunc) error {
+		for {
+			pinned := c.balancer.pinned()
+			err := f(rpcCtx)
+			if err == nil {
+				return nil
+			}
+			if logger.V(4) {
+				logger.Infof("clientv3/auth-retry: error %q on pinned endpoint %q", err.Error(), pinned)
+			}
+			// always stop retry on etcd errors other than invalid auth token
+			if rpctypes.Error(err) == rpctypes.ErrInvalidAuthToken {
+				gterr := c.getToken(rpcCtx)
+				if gterr != nil {
+					if logger.V(4) {
+						logger.Infof("clientv3/auth-retry: cannot retry due to error %q(%q) on pinned endpoint %q", err.Error(), gterr.Error(), pinned)
+					}
+					return err // return the original error for simplicity
+				}
+				continue
+			}
+			return err
+		}
+	}
+}
+
+// RetryKVClient implements a KVClient.
+func RetryKVClient(c *Client) pb.KVClient {
+	repeatableRetry := c.newRetryWrapper(isRepeatableStopError)
+	nonRepeatableRetry := c.newRetryWrapper(isNonRepeatableStopError)
+	conn := pb.NewKVClient(c.conn)
+	retryBasic := &retryKVClient{&nonRepeatableKVClient{conn, nonRepeatableRetry}, repeatableRetry}
+	retryAuthWrapper := c.newAuthRetryWrapper()
+	return &retryKVClient{
+		&nonRepeatableKVClient{retryBasic, retryAuthWrapper},
+		retryAuthWrapper}
+}
+
+type retryKVClient struct {
+	*nonRepeatableKVClient
+	repeatableRetry retryRPCFunc
+}
+
+func (rkv *retryKVClient) Range(ctx context.Context, in *pb.RangeRequest, opts ...grpc.CallOption) (resp *pb.RangeResponse, err error) {
+	err = rkv.repeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rkv.kc.Range(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+type nonRepeatableKVClient struct {
+	kc                 pb.KVClient
+	nonRepeatableRetry retryRPCFunc
+}
+
+func (rkv *nonRepeatableKVClient) Put(ctx context.Context, in *pb.PutRequest, opts ...grpc.CallOption) (resp *pb.PutResponse, err error) {
+	err = rkv.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rkv.kc.Put(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rkv *nonRepeatableKVClient) DeleteRange(ctx context.Context, in *pb.DeleteRangeRequest, opts ...grpc.CallOption) (resp *pb.DeleteRangeResponse, err error) {
+	err = rkv.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rkv.kc.DeleteRange(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rkv *nonRepeatableKVClient) Txn(ctx context.Context, in *pb.TxnRequest, opts ...grpc.CallOption) (resp *pb.TxnResponse, err error) {
+	// TODO: repeatableRetry if read-only txn
+	err = rkv.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rkv.kc.Txn(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rkv *nonRepeatableKVClient) Compact(ctx context.Context, in *pb.CompactionRequest, opts ...grpc.CallOption) (resp *pb.CompactionResponse, err error) {
+	err = rkv.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rkv.kc.Compact(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+type retryLeaseClient struct {
+	lc              pb.LeaseClient
+	repeatableRetry retryRPCFunc
+}
+
+// RetryLeaseClient implements a LeaseClient.
+func RetryLeaseClient(c *Client) pb.LeaseClient {
+	retry := &retryLeaseClient{
+		pb.NewLeaseClient(c.conn),
+		c.newRetryWrapper(isRepeatableStopError),
+	}
+	return &retryLeaseClient{retry, c.newAuthRetryWrapper()}
+}
+
+func (rlc *retryLeaseClient) LeaseTimeToLive(ctx context.Context, in *pb.LeaseTimeToLiveRequest, opts ...grpc.CallOption) (resp *pb.LeaseTimeToLiveResponse, err error) {
+	err = rlc.repeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rlc.lc.LeaseTimeToLive(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rlc *retryLeaseClient) LeaseLeases(ctx context.Context, in *pb.LeaseLeasesRequest, opts ...grpc.CallOption) (resp *pb.LeaseLeasesResponse, err error) {
+	err = rlc.repeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rlc.lc.LeaseLeases(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rlc *retryLeaseClient) LeaseGrant(ctx context.Context, in *pb.LeaseGrantRequest, opts ...grpc.CallOption) (resp *pb.LeaseGrantResponse, err error) {
+	err = rlc.repeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rlc.lc.LeaseGrant(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+
+}
+
+func (rlc *retryLeaseClient) LeaseRevoke(ctx context.Context, in *pb.LeaseRevokeRequest, opts ...grpc.CallOption) (resp *pb.LeaseRevokeResponse, err error) {
+	err = rlc.repeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rlc.lc.LeaseRevoke(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rlc *retryLeaseClient) LeaseKeepAlive(ctx context.Context, opts ...grpc.CallOption) (stream pb.Lease_LeaseKeepAliveClient, err error) {
+	err = rlc.repeatableRetry(ctx, func(rctx context.Context) error {
+		stream, err = rlc.lc.LeaseKeepAlive(rctx, opts...)
+		return err
+	})
+	return stream, err
+}
+
+type retryClusterClient struct {
+	*nonRepeatableClusterClient
+	repeatableRetry retryRPCFunc
+}
+
+// RetryClusterClient implements a ClusterClient.
+func RetryClusterClient(c *Client) pb.ClusterClient {
+	repeatableRetry := c.newRetryWrapper(isRepeatableStopError)
+	nonRepeatableRetry := c.newRetryWrapper(isNonRepeatableStopError)
+	cc := pb.NewClusterClient(c.conn)
+	return &retryClusterClient{&nonRepeatableClusterClient{cc, nonRepeatableRetry}, repeatableRetry}
+}
+
+func (rcc *retryClusterClient) MemberList(ctx context.Context, in *pb.MemberListRequest, opts ...grpc.CallOption) (resp *pb.MemberListResponse, err error) {
+	err = rcc.repeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rcc.cc.MemberList(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+type nonRepeatableClusterClient struct {
+	cc                 pb.ClusterClient
+	nonRepeatableRetry retryRPCFunc
+}
+
+func (rcc *nonRepeatableClusterClient) MemberAdd(ctx context.Context, in *pb.MemberAddRequest, opts ...grpc.CallOption) (resp *pb.MemberAddResponse, err error) {
+	err = rcc.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rcc.cc.MemberAdd(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rcc *nonRepeatableClusterClient) MemberRemove(ctx context.Context, in *pb.MemberRemoveRequest, opts ...grpc.CallOption) (resp *pb.MemberRemoveResponse, err error) {
+	err = rcc.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rcc.cc.MemberRemove(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rcc *nonRepeatableClusterClient) MemberUpdate(ctx context.Context, in *pb.MemberUpdateRequest, opts ...grpc.CallOption) (resp *pb.MemberUpdateResponse, err error) {
+	err = rcc.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rcc.cc.MemberUpdate(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+// RetryMaintenanceClient implements a Maintenance.
+func RetryMaintenanceClient(c *Client, conn *grpc.ClientConn) pb.MaintenanceClient {
+	repeatableRetry := c.newRetryWrapper(isRepeatableStopError)
+	nonRepeatableRetry := c.newRetryWrapper(isNonRepeatableStopError)
+	mc := pb.NewMaintenanceClient(conn)
+	return &retryMaintenanceClient{&nonRepeatableMaintenanceClient{mc, nonRepeatableRetry}, repeatableRetry}
+}
+
+type retryMaintenanceClient struct {
+	*nonRepeatableMaintenanceClient
+	repeatableRetry retryRPCFunc
+}
+
+func (rmc *retryMaintenanceClient) Alarm(ctx context.Context, in *pb.AlarmRequest, opts ...grpc.CallOption) (resp *pb.AlarmResponse, err error) {
+	err = rmc.repeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rmc.mc.Alarm(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rmc *retryMaintenanceClient) Status(ctx context.Context, in *pb.StatusRequest, opts ...grpc.CallOption) (resp *pb.StatusResponse, err error) {
+	err = rmc.repeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rmc.mc.Status(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rmc *retryMaintenanceClient) Hash(ctx context.Context, in *pb.HashRequest, opts ...grpc.CallOption) (resp *pb.HashResponse, err error) {
+	err = rmc.repeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rmc.mc.Hash(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rmc *retryMaintenanceClient) HashKV(ctx context.Context, in *pb.HashKVRequest, opts ...grpc.CallOption) (resp *pb.HashKVResponse, err error) {
+	err = rmc.repeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rmc.mc.HashKV(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rmc *retryMaintenanceClient) Snapshot(ctx context.Context, in *pb.SnapshotRequest, opts ...grpc.CallOption) (stream pb.Maintenance_SnapshotClient, err error) {
+	err = rmc.repeatableRetry(ctx, func(rctx context.Context) error {
+		stream, err = rmc.mc.Snapshot(rctx, in, opts...)
+		return err
+	})
+	return stream, err
+}
+
+func (rmc *retryMaintenanceClient) MoveLeader(ctx context.Context, in *pb.MoveLeaderRequest, opts ...grpc.CallOption) (resp *pb.MoveLeaderResponse, err error) {
+	err = rmc.repeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rmc.mc.MoveLeader(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+type nonRepeatableMaintenanceClient struct {
+	mc                 pb.MaintenanceClient
+	nonRepeatableRetry retryRPCFunc
+}
+
+func (rmc *nonRepeatableMaintenanceClient) Defragment(ctx context.Context, in *pb.DefragmentRequest, opts ...grpc.CallOption) (resp *pb.DefragmentResponse, err error) {
+	err = rmc.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rmc.mc.Defragment(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+type retryAuthClient struct {
+	*nonRepeatableAuthClient
+	repeatableRetry retryRPCFunc
+}
+
+// RetryAuthClient implements a AuthClient.
+func RetryAuthClient(c *Client) pb.AuthClient {
+	repeatableRetry := c.newRetryWrapper(isRepeatableStopError)
+	nonRepeatableRetry := c.newRetryWrapper(isNonRepeatableStopError)
+	ac := pb.NewAuthClient(c.conn)
+	return &retryAuthClient{&nonRepeatableAuthClient{ac, nonRepeatableRetry}, repeatableRetry}
+}
+
+func (rac *retryAuthClient) UserList(ctx context.Context, in *pb.AuthUserListRequest, opts ...grpc.CallOption) (resp *pb.AuthUserListResponse, err error) {
+	err = rac.repeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.UserList(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rac *retryAuthClient) UserGet(ctx context.Context, in *pb.AuthUserGetRequest, opts ...grpc.CallOption) (resp *pb.AuthUserGetResponse, err error) {
+	err = rac.repeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.UserGet(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rac *retryAuthClient) RoleGet(ctx context.Context, in *pb.AuthRoleGetRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleGetResponse, err error) {
+	err = rac.repeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.RoleGet(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rac *retryAuthClient) RoleList(ctx context.Context, in *pb.AuthRoleListRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleListResponse, err error) {
+	err = rac.repeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.RoleList(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+type nonRepeatableAuthClient struct {
+	ac                 pb.AuthClient
+	nonRepeatableRetry retryRPCFunc
+}
+
+func (rac *nonRepeatableAuthClient) AuthEnable(ctx context.Context, in *pb.AuthEnableRequest, opts ...grpc.CallOption) (resp *pb.AuthEnableResponse, err error) {
+	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.AuthEnable(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rac *nonRepeatableAuthClient) AuthDisable(ctx context.Context, in *pb.AuthDisableRequest, opts ...grpc.CallOption) (resp *pb.AuthDisableResponse, err error) {
+	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.AuthDisable(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rac *nonRepeatableAuthClient) UserAdd(ctx context.Context, in *pb.AuthUserAddRequest, opts ...grpc.CallOption) (resp *pb.AuthUserAddResponse, err error) {
+	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.UserAdd(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rac *nonRepeatableAuthClient) UserDelete(ctx context.Context, in *pb.AuthUserDeleteRequest, opts ...grpc.CallOption) (resp *pb.AuthUserDeleteResponse, err error) {
+	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.UserDelete(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rac *nonRepeatableAuthClient) UserChangePassword(ctx context.Context, in *pb.AuthUserChangePasswordRequest, opts ...grpc.CallOption) (resp *pb.AuthUserChangePasswordResponse, err error) {
+	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.UserChangePassword(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rac *nonRepeatableAuthClient) UserGrantRole(ctx context.Context, in *pb.AuthUserGrantRoleRequest, opts ...grpc.CallOption) (resp *pb.AuthUserGrantRoleResponse, err error) {
+	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.UserGrantRole(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rac *nonRepeatableAuthClient) UserRevokeRole(ctx context.Context, in *pb.AuthUserRevokeRoleRequest, opts ...grpc.CallOption) (resp *pb.AuthUserRevokeRoleResponse, err error) {
+	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.UserRevokeRole(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rac *nonRepeatableAuthClient) RoleAdd(ctx context.Context, in *pb.AuthRoleAddRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleAddResponse, err error) {
+	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.RoleAdd(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rac *nonRepeatableAuthClient) RoleDelete(ctx context.Context, in *pb.AuthRoleDeleteRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleDeleteResponse, err error) {
+	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.RoleDelete(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rac *nonRepeatableAuthClient) RoleGrantPermission(ctx context.Context, in *pb.AuthRoleGrantPermissionRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleGrantPermissionResponse, err error) {
+	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.RoleGrantPermission(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rac *nonRepeatableAuthClient) RoleRevokePermission(ctx context.Context, in *pb.AuthRoleRevokePermissionRequest, opts ...grpc.CallOption) (resp *pb.AuthRoleRevokePermissionResponse, err error) {
+	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.RoleRevokePermission(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
+
+func (rac *nonRepeatableAuthClient) Authenticate(ctx context.Context, in *pb.AuthenticateRequest, opts ...grpc.CallOption) (resp *pb.AuthenticateResponse, err error) {
+	err = rac.nonRepeatableRetry(ctx, func(rctx context.Context) error {
+		resp, err = rac.ac.Authenticate(rctx, in, opts...)
+		return err
+	})
+	return resp, err
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/sort.go b/vendor/github.com/coreos/etcd/clientv3/sort.go
new file mode 100644
index 000000000..2bb9d9a13
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/sort.go
@@ -0,0 +1,37 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+type SortTarget int
+type SortOrder int
+
+const (
+	SortNone SortOrder = iota
+	SortAscend
+	SortDescend
+)
+
+const (
+	SortByKey SortTarget = iota
+	SortByVersion
+	SortByCreateRevision
+	SortByModRevision
+	SortByValue
+)
+
+type SortOption struct {
+	Target SortTarget
+	Order  SortOrder
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/txn.go b/vendor/github.com/coreos/etcd/clientv3/txn.go
new file mode 100644
index 000000000..8169b6215
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/txn.go
@@ -0,0 +1,147 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import (
+	"context"
+	"sync"
+
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+)
+
+// Txn is the interface that wraps mini-transactions.
+//
+//	 Txn(context.TODO()).If(
+//	  Compare(Value(k1), ">", v1),
+//	  Compare(Version(k1), "=", 2)
+//	 ).Then(
+//	  OpPut(k2,v2), OpPut(k3,v3)
+//	 ).Else(
+//	  OpPut(k4,v4), OpPut(k5,v5)
+//	 ).Commit()
+//
+type Txn interface {
+	// If takes a list of comparison. If all comparisons passed in succeed,
+	// the operations passed into Then() will be executed. Or the operations
+	// passed into Else() will be executed.
+	If(cs ...Cmp) Txn
+
+	// Then takes a list of operations. The Ops list will be executed, if the
+	// comparisons passed in If() succeed.
+	Then(ops ...Op) Txn
+
+	// Else takes a list of operations. The Ops list will be executed, if the
+	// comparisons passed in If() fail.
+	Else(ops ...Op) Txn
+
+	// Commit tries to commit the transaction.
+	Commit() (*TxnResponse, error)
+}
+
+type txn struct {
+	kv  *kv
+	ctx context.Context
+
+	mu    sync.Mutex
+	cif   bool
+	cthen bool
+	celse bool
+
+	isWrite bool
+
+	cmps []*pb.Compare
+
+	sus []*pb.RequestOp
+	fas []*pb.RequestOp
+}
+
+func (txn *txn) If(cs ...Cmp) Txn {
+	txn.mu.Lock()
+	defer txn.mu.Unlock()
+
+	if txn.cif {
+		panic("cannot call If twice!")
+	}
+
+	if txn.cthen {
+		panic("cannot call If after Then!")
+	}
+
+	if txn.celse {
+		panic("cannot call If after Else!")
+	}
+
+	txn.cif = true
+
+	for i := range cs {
+		txn.cmps = append(txn.cmps, (*pb.Compare)(&cs[i]))
+	}
+
+	return txn
+}
+
+func (txn *txn) Then(ops ...Op) Txn {
+	txn.mu.Lock()
+	defer txn.mu.Unlock()
+
+	if txn.cthen {
+		panic("cannot call Then twice!")
+	}
+	if txn.celse {
+		panic("cannot call Then after Else!")
+	}
+
+	txn.cthen = true
+
+	for _, op := range ops {
+		txn.isWrite = txn.isWrite || op.isWrite()
+		txn.sus = append(txn.sus, op.toRequestOp())
+	}
+
+	return txn
+}
+
+func (txn *txn) Else(ops ...Op) Txn {
+	txn.mu.Lock()
+	defer txn.mu.Unlock()
+
+	if txn.celse {
+		panic("cannot call Else twice!")
+	}
+
+	txn.celse = true
+
+	for _, op := range ops {
+		txn.isWrite = txn.isWrite || op.isWrite()
+		txn.fas = append(txn.fas, op.toRequestOp())
+	}
+
+	return txn
+}
+
+func (txn *txn) Commit() (*TxnResponse, error) {
+	txn.mu.Lock()
+	defer txn.mu.Unlock()
+
+	r := &pb.TxnRequest{Compare: txn.cmps, Success: txn.sus, Failure: txn.fas}
+
+	var resp *pb.TxnResponse
+	var err error
+	resp, err = txn.kv.remote.Txn(txn.ctx, r)
+	if err != nil {
+		return nil, toErr(txn.ctx, err)
+	}
+	return (*TxnResponse)(resp), nil
+}
diff --git a/vendor/github.com/coreos/etcd/clientv3/watch.go b/vendor/github.com/coreos/etcd/clientv3/watch.go
new file mode 100644
index 000000000..91e6db26a
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/clientv3/watch.go
@@ -0,0 +1,806 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package clientv3
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"time"
+
+	v3rpc "github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes"
+	pb "github.com/coreos/etcd/etcdserver/etcdserverpb"
+	mvccpb "github.com/coreos/etcd/mvcc/mvccpb"
+
+	"google.golang.org/grpc"
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/metadata"
+)
+
+const (
+	EventTypeDelete = mvccpb.DELETE
+	EventTypePut    = mvccpb.PUT
+
+	closeSendErrTimeout = 250 * time.Millisecond
+)
+
+type Event mvccpb.Event
+
+type WatchChan <-chan WatchResponse
+
+type Watcher interface {
+	// Watch watches on a key or prefix. The watched events will be returned
+	// through the returned channel. If revisions waiting to be sent over the
+	// watch are compacted, then the watch will be canceled by the server, the
+	// client will post a compacted error watch response, and the channel will close.
+	Watch(ctx context.Context, key string, opts ...OpOption) WatchChan
+
+	// Close closes the watcher and cancels all watch requests.
+	Close() error
+}
+
+type WatchResponse struct {
+	Header pb.ResponseHeader
+	Events []*Event
+
+	// CompactRevision is the minimum revision the watcher may receive.
+	CompactRevision int64
+
+	// Canceled is used to indicate watch failure.
+	// If the watch failed and the stream was about to close, before the channel is closed,
+	// the channel sends a final response that has Canceled set to true with a non-nil Err().
+	Canceled bool
+
+	// Created is used to indicate the creation of the watcher.
+	Created bool
+
+	closeErr error
+
+	// cancelReason is a reason of canceling watch
+	cancelReason string
+}
+
+// IsCreate returns true if the event tells that the key is newly created.
+func (e *Event) IsCreate() bool {
+	return e.Type == EventTypePut && e.Kv.CreateRevision == e.Kv.ModRevision
+}
+
+// IsModify returns true if the event tells that a new value is put on existing key.
+func (e *Event) IsModify() bool {
+	return e.Type == EventTypePut && e.Kv.CreateRevision != e.Kv.ModRevision
+}
+
+// Err is the error value if this WatchResponse holds an error.
+func (wr *WatchResponse) Err() error {
+	switch {
+	case wr.closeErr != nil:
+		return v3rpc.Error(wr.closeErr)
+	case wr.CompactRevision != 0:
+		return v3rpc.ErrCompacted
+	case wr.Canceled:
+		if len(wr.cancelReason) != 0 {
+			return v3rpc.Error(grpc.Errorf(codes.FailedPrecondition, "%s", wr.cancelReason))
+		}
+		return v3rpc.ErrFutureRev
+	}
+	return nil
+}
+
+// IsProgressNotify returns true if the WatchResponse is progress notification.
+func (wr *WatchResponse) IsProgressNotify() bool {
+	return len(wr.Events) == 0 && !wr.Canceled && !wr.Created && wr.CompactRevision == 0 && wr.Header.Revision != 0
+}
+
+// watcher implements the Watcher interface
+type watcher struct {
+	remote pb.WatchClient
+
+	// mu protects the grpc streams map
+	mu sync.RWMutex
+
+	// streams holds all the active grpc streams keyed by ctx value.
+	streams map[string]*watchGrpcStream
+}
+
+// watchGrpcStream tracks all watch resources attached to a single grpc stream.
+type watchGrpcStream struct {
+	owner  *watcher
+	remote pb.WatchClient
+
+	// ctx controls internal remote.Watch requests
+	ctx context.Context
+	// ctxKey is the key used when looking up this stream's context
+	ctxKey string
+	cancel context.CancelFunc
+
+	// substreams holds all active watchers on this grpc stream
+	substreams map[int64]*watcherStream
+	// resuming holds all resuming watchers on this grpc stream
+	resuming []*watcherStream
+
+	// reqc sends a watch request from Watch() to the main goroutine
+	reqc chan *watchRequest
+	// respc receives data from the watch client
+	respc chan *pb.WatchResponse
+	// donec closes to broadcast shutdown
+	donec chan struct{}
+	// errc transmits errors from grpc Recv to the watch stream reconnect logic
+	errc chan error
+	// closingc gets the watcherStream of closing watchers
+	closingc chan *watcherStream
+	// wg is Done when all substream goroutines have exited
+	wg sync.WaitGroup
+
+	// resumec closes to signal that all substreams should begin resuming
+	resumec chan struct{}
+	// closeErr is the error that closed the watch stream
+	closeErr error
+}
+
+// watchRequest is issued by the subscriber to start a new watcher
+type watchRequest struct {
+	ctx context.Context
+	key string
+	end string
+	rev int64
+	// send created notification event if this field is true
+	createdNotify bool
+	// progressNotify is for progress updates
+	progressNotify bool
+	// filters is the list of events to filter out
+	filters []pb.WatchCreateRequest_FilterType
+	// get the previous key-value pair before the event happens
+	prevKV bool
+	// retc receives a chan WatchResponse once the watcher is established
+	retc chan chan WatchResponse
+}
+
+// watcherStream represents a registered watcher
+type watcherStream struct {
+	// initReq is the request that initiated this request
+	initReq watchRequest
+
+	// outc publishes watch responses to subscriber
+	outc chan WatchResponse
+	// recvc buffers watch responses before publishing
+	recvc chan *WatchResponse
+	// donec closes when the watcherStream goroutine stops.
+	donec chan struct{}
+	// closing is set to true when stream should be scheduled to shutdown.
+	closing bool
+	// id is the registered watch id on the grpc stream
+	id int64
+
+	// buf holds all events received from etcd but not yet consumed by the client
+	buf []*WatchResponse
+}
+
+func NewWatcher(c *Client) Watcher {
+	return NewWatchFromWatchClient(pb.NewWatchClient(c.conn))
+}
+
+func NewWatchFromWatchClient(wc pb.WatchClient) Watcher {
+	return &watcher{
+		remote:  wc,
+		streams: make(map[string]*watchGrpcStream),
+	}
+}
+
+// never closes
+var valCtxCh = make(chan struct{})
+var zeroTime = time.Unix(0, 0)
+
+// ctx with only the values; never Done
+type valCtx struct{ context.Context }
+
+func (vc *valCtx) Deadline() (time.Time, bool) { return zeroTime, false }
+func (vc *valCtx) Done() <-chan struct{}       { return valCtxCh }
+func (vc *valCtx) Err() error                  { return nil }
+
+func (w *watcher) newWatcherGrpcStream(inctx context.Context) *watchGrpcStream {
+	ctx, cancel := context.WithCancel(&valCtx{inctx})
+	wgs := &watchGrpcStream{
+		owner:      w,
+		remote:     w.remote,
+		ctx:        ctx,
+		ctxKey:     streamKeyFromCtx(inctx),
+		cancel:     cancel,
+		substreams: make(map[int64]*watcherStream),
+		respc:      make(chan *pb.WatchResponse),
+		reqc:       make(chan *watchRequest),
+		donec:      make(chan struct{}),
+		errc:       make(chan error, 1),
+		closingc:   make(chan *watcherStream),
+		resumec:    make(chan struct{}),
+	}
+	go wgs.run()
+	return wgs
+}
+
+// Watch posts a watch request to run() and waits for a new watcher channel
+func (w *watcher) Watch(ctx context.Context, key string, opts ...OpOption) WatchChan {
+	ow := opWatch(key, opts...)
+
+	var filters []pb.WatchCreateRequest_FilterType
+	if ow.filterPut {
+		filters = append(filters, pb.WatchCreateRequest_NOPUT)
+	}
+	if ow.filterDelete {
+		filters = append(filters, pb.WatchCreateRequest_NODELETE)
+	}
+
+	wr := &watchRequest{
+		ctx:            ctx,
+		createdNotify:  ow.createdNotify,
+		key:            string(ow.key),
+		end:            string(ow.end),
+		rev:            ow.rev,
+		progressNotify: ow.progressNotify,
+		filters:        filters,
+		prevKV:         ow.prevKV,
+		retc:           make(chan chan WatchResponse, 1),
+	}
+
+	ok := false
+	ctxKey := streamKeyFromCtx(ctx)
+
+	// find or allocate appropriate grpc watch stream
+	w.mu.Lock()
+	if w.streams == nil {
+		// closed
+		w.mu.Unlock()
+		ch := make(chan WatchResponse)
+		close(ch)
+		return ch
+	}
+	wgs := w.streams[ctxKey]
+	if wgs == nil {
+		wgs = w.newWatcherGrpcStream(ctx)
+		w.streams[ctxKey] = wgs
+	}
+	donec := wgs.donec
+	reqc := wgs.reqc
+	w.mu.Unlock()
+
+	// couldn't create channel; return closed channel
+	closeCh := make(chan WatchResponse, 1)
+
+	// submit request
+	select {
+	case reqc <- wr:
+		ok = true
+	case <-wr.ctx.Done():
+	case <-donec:
+		if wgs.closeErr != nil {
+			closeCh <- WatchResponse{closeErr: wgs.closeErr}
+			break
+		}
+		// retry; may have dropped stream from no ctxs
+		return w.Watch(ctx, key, opts...)
+	}
+
+	// receive channel
+	if ok {
+		select {
+		case ret := <-wr.retc:
+			return ret
+		case <-ctx.Done():
+		case <-donec:
+			if wgs.closeErr != nil {
+				closeCh <- WatchResponse{closeErr: wgs.closeErr}
+				break
+			}
+			// retry; may have dropped stream from no ctxs
+			return w.Watch(ctx, key, opts...)
+		}
+	}
+
+	close(closeCh)
+	return closeCh
+}
+
+func (w *watcher) Close() (err error) {
+	w.mu.Lock()
+	streams := w.streams
+	w.streams = nil
+	w.mu.Unlock()
+	for _, wgs := range streams {
+		if werr := wgs.close(); werr != nil {
+			err = werr
+		}
+	}
+	return err
+}
+
+func (w *watchGrpcStream) close() (err error) {
+	w.cancel()
+	<-w.donec
+	select {
+	case err = <-w.errc:
+	default:
+	}
+	return toErr(w.ctx, err)
+}
+
+func (w *watcher) closeStream(wgs *watchGrpcStream) {
+	w.mu.Lock()
+	close(wgs.donec)
+	wgs.cancel()
+	if w.streams != nil {
+		delete(w.streams, wgs.ctxKey)
+	}
+	w.mu.Unlock()
+}
+
+func (w *watchGrpcStream) addSubstream(resp *pb.WatchResponse, ws *watcherStream) {
+	if resp.WatchId == -1 {
+		// failed; no channel
+		close(ws.recvc)
+		return
+	}
+	ws.id = resp.WatchId
+	w.substreams[ws.id] = ws
+}
+
+func (w *watchGrpcStream) sendCloseSubstream(ws *watcherStream, resp *WatchResponse) {
+	select {
+	case ws.outc <- *resp:
+	case <-ws.initReq.ctx.Done():
+	case <-time.After(closeSendErrTimeout):
+	}
+	close(ws.outc)
+}
+
+func (w *watchGrpcStream) closeSubstream(ws *watcherStream) {
+	// send channel response in case stream was never established
+	select {
+	case ws.initReq.retc <- ws.outc:
+	default:
+	}
+	// close subscriber's channel
+	if closeErr := w.closeErr; closeErr != nil && ws.initReq.ctx.Err() == nil {
+		go w.sendCloseSubstream(ws, &WatchResponse{closeErr: w.closeErr})
+	} else if ws.outc != nil {
+		close(ws.outc)
+	}
+	if ws.id != -1 {
+		delete(w.substreams, ws.id)
+		return
+	}
+	for i := range w.resuming {
+		if w.resuming[i] == ws {
+			w.resuming[i] = nil
+			return
+		}
+	}
+}
+
+// run is the root of the goroutines for managing a watcher client
+func (w *watchGrpcStream) run() {
+	var wc pb.Watch_WatchClient
+	var closeErr error
+
+	// substreams marked to close but goroutine still running; needed for
+	// avoiding double-closing recvc on grpc stream teardown
+	closing := make(map[*watcherStream]struct{})
+
+	defer func() {
+		w.closeErr = closeErr
+		// shutdown substreams and resuming substreams
+		for _, ws := range w.substreams {
+			if _, ok := closing[ws]; !ok {
+				close(ws.recvc)
+				closing[ws] = struct{}{}
+			}
+		}
+		for _, ws := range w.resuming {
+			if _, ok := closing[ws]; ws != nil && !ok {
+				close(ws.recvc)
+				closing[ws] = struct{}{}
+			}
+		}
+		w.joinSubstreams()
+		for range closing {
+			w.closeSubstream(<-w.closingc)
+		}
+		w.wg.Wait()
+		w.owner.closeStream(w)
+	}()
+
+	// start a stream with the etcd grpc server
+	if wc, closeErr = w.newWatchClient(); closeErr != nil {
+		return
+	}
+
+	cancelSet := make(map[int64]struct{})
+
+	for {
+		select {
+		// Watch() requested
+		case wreq := <-w.reqc:
+			outc := make(chan WatchResponse, 1)
+			ws := &watcherStream{
+				initReq: *wreq,
+				id:      -1,
+				outc:    outc,
+				// unbuffered so resumes won't cause repeat events
+				recvc: make(chan *WatchResponse),
+			}
+
+			ws.donec = make(chan struct{})
+			w.wg.Add(1)
+			go w.serveSubstream(ws, w.resumec)
+
+			// queue up for watcher creation/resume
+			w.resuming = append(w.resuming, ws)
+			if len(w.resuming) == 1 {
+				// head of resume queue, can register a new watcher
+				wc.Send(ws.initReq.toPB())
+			}
+		// New events from the watch client
+		case pbresp := <-w.respc:
+			switch {
+			case pbresp.Created:
+				// response to head of queue creation
+				if ws := w.resuming[0]; ws != nil {
+					w.addSubstream(pbresp, ws)
+					w.dispatchEvent(pbresp)
+					w.resuming[0] = nil
+				}
+				if ws := w.nextResume(); ws != nil {
+					wc.Send(ws.initReq.toPB())
+				}
+			case pbresp.Canceled && pbresp.CompactRevision == 0:
+				delete(cancelSet, pbresp.WatchId)
+				if ws, ok := w.substreams[pbresp.WatchId]; ok {
+					// signal to stream goroutine to update closingc
+					close(ws.recvc)
+					closing[ws] = struct{}{}
+				}
+			default:
+				// dispatch to appropriate watch stream
+				if ok := w.dispatchEvent(pbresp); ok {
+					break
+				}
+				// watch response on unexpected watch id; cancel id
+				if _, ok := cancelSet[pbresp.WatchId]; ok {
+					break
+				}
+				cancelSet[pbresp.WatchId] = struct{}{}
+				cr := &pb.WatchRequest_CancelRequest{
+					CancelRequest: &pb.WatchCancelRequest{
+						WatchId: pbresp.WatchId,
+					},
+				}
+				req := &pb.WatchRequest{RequestUnion: cr}
+				wc.Send(req)
+			}
+		// watch client failed on Recv; spawn another if possible
+		case err := <-w.errc:
+			if isHaltErr(w.ctx, err) || toErr(w.ctx, err) == v3rpc.ErrNoLeader {
+				closeErr = err
+				return
+			}
+			if wc, closeErr = w.newWatchClient(); closeErr != nil {
+				return
+			}
+			if ws := w.nextResume(); ws != nil {
+				wc.Send(ws.initReq.toPB())
+			}
+			cancelSet = make(map[int64]struct{})
+		case <-w.ctx.Done():
+			return
+		case ws := <-w.closingc:
+			w.closeSubstream(ws)
+			delete(closing, ws)
+			if len(w.substreams)+len(w.resuming) == 0 {
+				// no more watchers on this stream, shutdown
+				return
+			}
+		}
+	}
+}
+
+// nextResume chooses the next resuming to register with the grpc stream. Abandoned
+// streams are marked as nil in the queue since the head must wait for its inflight registration.
+func (w *watchGrpcStream) nextResume() *watcherStream {
+	for len(w.resuming) != 0 {
+		if w.resuming[0] != nil {
+			return w.resuming[0]
+		}
+		w.resuming = w.resuming[1:len(w.resuming)]
+	}
+	return nil
+}
+
+// dispatchEvent sends a WatchResponse to the appropriate watcher stream
+func (w *watchGrpcStream) dispatchEvent(pbresp *pb.WatchResponse) bool {
+	events := make([]*Event, len(pbresp.Events))
+	for i, ev := range pbresp.Events {
+		events[i] = (*Event)(ev)
+	}
+	wr := &WatchResponse{
+		Header:          *pbresp.Header,
+		Events:          events,
+		CompactRevision: pbresp.CompactRevision,
+		Created:         pbresp.Created,
+		Canceled:        pbresp.Canceled,
+		cancelReason:    pbresp.CancelReason,
+	}
+	ws, ok := w.substreams[pbresp.WatchId]
+	if !ok {
+		return false
+	}
+	select {
+	case ws.recvc <- wr:
+	case <-ws.donec:
+		return false
+	}
+	return true
+}
+
+// serveWatchClient forwards messages from the grpc stream to run()
+func (w *watchGrpcStream) serveWatchClient(wc pb.Watch_WatchClient) {
+	for {
+		resp, err := wc.Recv()
+		if err != nil {
+			select {
+			case w.errc <- err:
+			case <-w.donec:
+			}
+			return
+		}
+		select {
+		case w.respc <- resp:
+		case <-w.donec:
+			return
+		}
+	}
+}
+
+// serveSubstream forwards watch responses from run() to the subscriber
+func (w *watchGrpcStream) serveSubstream(ws *watcherStream, resumec chan struct{}) {
+	if ws.closing {
+		panic("created substream goroutine but substream is closing")
+	}
+
+	// nextRev is the minimum expected next revision
+	nextRev := ws.initReq.rev
+	resuming := false
+	defer func() {
+		if !resuming {
+			ws.closing = true
+		}
+		close(ws.donec)
+		if !resuming {
+			w.closingc <- ws
+		}
+		w.wg.Done()
+	}()
+
+	emptyWr := &WatchResponse{}
+	for {
+		curWr := emptyWr
+		outc := ws.outc
+
+		if len(ws.buf) > 0 {
+			curWr = ws.buf[0]
+		} else {
+			outc = nil
+		}
+		select {
+		case outc <- *curWr:
+			if ws.buf[0].Err() != nil {
+				return
+			}
+			ws.buf[0] = nil
+			ws.buf = ws.buf[1:]
+		case wr, ok := <-ws.recvc:
+			if !ok {
+				// shutdown from closeSubstream
+				return
+			}
+
+			if wr.Created {
+				if ws.initReq.retc != nil {
+					ws.initReq.retc <- ws.outc
+					// to prevent next write from taking the slot in buffered channel
+					// and posting duplicate create events
+					ws.initReq.retc = nil
+
+					// send first creation event only if requested
+					if ws.initReq.createdNotify {
+						ws.outc <- *wr
+					}
+					// once the watch channel is returned, a current revision
+					// watch must resume at the store revision. This is necessary
+					// for the following case to work as expected:
+					//	wch := m1.Watch("a")
+					//	m2.Put("a", "b")
+					//	<-wch
+					// If the revision is only bound on the first observed event,
+					// if wch is disconnected before the Put is issued, then reconnects
+					// after it is committed, it'll miss the Put.
+					if ws.initReq.rev == 0 {
+						nextRev = wr.Header.Revision
+					}
+				}
+			} else {
+				// current progress of watch; <= store revision
+				nextRev = wr.Header.Revision
+			}
+
+			if len(wr.Events) > 0 {
+				nextRev = wr.Events[len(wr.Events)-1].Kv.ModRevision + 1
+			}
+			ws.initReq.rev = nextRev
+
+			// created event is already sent above,
+			// watcher should not post duplicate events
+			if wr.Created {
+				continue
+			}
+
+			// TODO pause channel if buffer gets too large
+			ws.buf = append(ws.buf, wr)
+		case <-w.ctx.Done():
+			return
+		case <-ws.initReq.ctx.Done():
+			return
+		case <-resumec:
+			resuming = true
+			return
+		}
+	}
+	// lazily send cancel message if events on missing id
+}
+
+func (w *watchGrpcStream) newWatchClient() (pb.Watch_WatchClient, error) {
+	// mark all substreams as resuming
+	close(w.resumec)
+	w.resumec = make(chan struct{})
+	w.joinSubstreams()
+	for _, ws := range w.substreams {
+		ws.id = -1
+		w.resuming = append(w.resuming, ws)
+	}
+	// strip out nils, if any
+	var resuming []*watcherStream
+	for _, ws := range w.resuming {
+		if ws != nil {
+			resuming = append(resuming, ws)
+		}
+	}
+	w.resuming = resuming
+	w.substreams = make(map[int64]*watcherStream)
+
+	// connect to grpc stream while accepting watcher cancelation
+	stopc := make(chan struct{})
+	donec := w.waitCancelSubstreams(stopc)
+	wc, err := w.openWatchClient()
+	close(stopc)
+	<-donec
+
+	// serve all non-closing streams, even if there's a client error
+	// so that the teardown path can shutdown the streams as expected.
+	for _, ws := range w.resuming {
+		if ws.closing {
+			continue
+		}
+		ws.donec = make(chan struct{})
+		w.wg.Add(1)
+		go w.serveSubstream(ws, w.resumec)
+	}
+
+	if err != nil {
+		return nil, v3rpc.Error(err)
+	}
+
+	// receive data from new grpc stream
+	go w.serveWatchClient(wc)
+	return wc, nil
+}
+
+func (w *watchGrpcStream) waitCancelSubstreams(stopc <-chan struct{}) <-chan struct{} {
+	var wg sync.WaitGroup
+	wg.Add(len(w.resuming))
+	donec := make(chan struct{})
+	for i := range w.resuming {
+		go func(ws *watcherStream) {
+			defer wg.Done()
+			if ws.closing {
+				if ws.initReq.ctx.Err() != nil && ws.outc != nil {
+					close(ws.outc)
+					ws.outc = nil
+				}
+				return
+			}
+			select {
+			case <-ws.initReq.ctx.Done():
+				// closed ws will be removed from resuming
+				ws.closing = true
+				close(ws.outc)
+				ws.outc = nil
+				w.wg.Add(1)
+				go func() {
+					defer w.wg.Done()
+					w.closingc <- ws
+				}()
+			case <-stopc:
+			}
+		}(w.resuming[i])
+	}
+	go func() {
+		defer close(donec)
+		wg.Wait()
+	}()
+	return donec
+}
+
+// joinSubstreams waits for all substream goroutines to complete.
+func (w *watchGrpcStream) joinSubstreams() {
+	for _, ws := range w.substreams {
+		<-ws.donec
+	}
+	for _, ws := range w.resuming {
+		if ws != nil {
+			<-ws.donec
+		}
+	}
+}
+
+// openWatchClient retries opening a watch client until success or halt.
+// manually retry in case "ws==nil && err==nil"
+// TODO: remove FailFast=false
+func (w *watchGrpcStream) openWatchClient() (ws pb.Watch_WatchClient, err error) {
+	for {
+		select {
+		case <-w.ctx.Done():
+			if err == nil {
+				return nil, w.ctx.Err()
+			}
+			return nil, err
+		default:
+		}
+		if ws, err = w.remote.Watch(w.ctx, grpc.FailFast(false)); ws != nil && err == nil {
+			break
+		}
+		if isHaltErr(w.ctx, err) {
+			return nil, v3rpc.Error(err)
+		}
+	}
+	return ws, nil
+}
+
+// toPB converts an internal watch request structure to its protobuf WatchRequest structure.
+func (wr *watchRequest) toPB() *pb.WatchRequest {
+	req := &pb.WatchCreateRequest{
+		StartRevision:  wr.rev,
+		Key:            []byte(wr.key),
+		RangeEnd:       []byte(wr.end),
+		ProgressNotify: wr.progressNotify,
+		Filters:        wr.filters,
+		PrevKv:         wr.prevKV,
+	}
+	cr := &pb.WatchRequest_CreateRequest{CreateRequest: req}
+	return &pb.WatchRequest{RequestUnion: cr}
+}
+
+func streamKeyFromCtx(ctx context.Context) string {
+	if md, ok := metadata.FromOutgoingContext(ctx); ok {
+		return fmt.Sprintf("%+v", md)
+	}
+	return ""
+}
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/doc.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/doc.go
new file mode 100644
index 000000000..f72c6a644
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/doc.go
@@ -0,0 +1,16 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package rpctypes has types and values shared by the etcd server and client for v3 RPC interaction.
+package rpctypes
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/error.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/error.go
new file mode 100644
index 000000000..446e4f6b8
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/error.go
@@ -0,0 +1,212 @@
+// Copyright 2015 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package rpctypes
+
+import (
+	"google.golang.org/grpc/codes"
+	"google.golang.org/grpc/status"
+)
+
+// server-side error
+var (
+	ErrGRPCEmptyKey      = status.New(codes.InvalidArgument, "etcdserver: key is not provided").Err()
+	ErrGRPCKeyNotFound   = status.New(codes.InvalidArgument, "etcdserver: key not found").Err()
+	ErrGRPCValueProvided = status.New(codes.InvalidArgument, "etcdserver: value is provided").Err()
+	ErrGRPCLeaseProvided = status.New(codes.InvalidArgument, "etcdserver: lease is provided").Err()
+	ErrGRPCTooManyOps    = status.New(codes.InvalidArgument, "etcdserver: too many operations in txn request").Err()
+	ErrGRPCDuplicateKey  = status.New(codes.InvalidArgument, "etcdserver: duplicate key given in txn request").Err()
+	ErrGRPCCompacted     = status.New(codes.OutOfRange, "etcdserver: mvcc: required revision has been compacted").Err()
+	ErrGRPCFutureRev     = status.New(codes.OutOfRange, "etcdserver: mvcc: required revision is a future revision").Err()
+	ErrGRPCNoSpace       = status.New(codes.ResourceExhausted, "etcdserver: mvcc: database space exceeded").Err()
+
+	ErrGRPCLeaseNotFound = status.New(codes.NotFound, "etcdserver: requested lease not found").Err()
+	ErrGRPCLeaseExist    = status.New(codes.FailedPrecondition, "etcdserver: lease already exists").Err()
+
+	ErrGRPCMemberExist            = status.New(codes.FailedPrecondition, "etcdserver: member ID already exist").Err()
+	ErrGRPCPeerURLExist           = status.New(codes.FailedPrecondition, "etcdserver: Peer URLs already exists").Err()
+	ErrGRPCMemberNotEnoughStarted = status.New(codes.FailedPrecondition, "etcdserver: re-configuration failed due to not enough started members").Err()
+	ErrGRPCMemberBadURLs          = status.New(codes.InvalidArgument, "etcdserver: given member URLs are invalid").Err()
+	ErrGRPCMemberNotFound         = status.New(codes.NotFound, "etcdserver: member not found").Err()
+
+	ErrGRPCRequestTooLarge        = status.New(codes.InvalidArgument, "etcdserver: request is too large").Err()
+	ErrGRPCRequestTooManyRequests = status.New(codes.ResourceExhausted, "etcdserver: too many requests").Err()
+
+	ErrGRPCRootUserNotExist     = status.New(codes.FailedPrecondition, "etcdserver: root user does not exist").Err()
+	ErrGRPCRootRoleNotExist     = status.New(codes.FailedPrecondition, "etcdserver: root user does not have root role").Err()
+	ErrGRPCUserAlreadyExist     = status.New(codes.FailedPrecondition, "etcdserver: user name already exists").Err()
+	ErrGRPCUserEmpty            = status.New(codes.InvalidArgument, "etcdserver: user name is empty").Err()
+	ErrGRPCUserNotFound         = status.New(codes.FailedPrecondition, "etcdserver: user name not found").Err()
+	ErrGRPCRoleAlreadyExist     = status.New(codes.FailedPrecondition, "etcdserver: role name already exists").Err()
+	ErrGRPCRoleNotFound         = status.New(codes.FailedPrecondition, "etcdserver: role name not found").Err()
+	ErrGRPCAuthFailed           = status.New(codes.InvalidArgument, "etcdserver: authentication failed, invalid user ID or password").Err()
+	ErrGRPCPermissionDenied     = status.New(codes.PermissionDenied, "etcdserver: permission denied").Err()
+	ErrGRPCRoleNotGranted       = status.New(codes.FailedPrecondition, "etcdserver: role is not granted to the user").Err()
+	ErrGRPCPermissionNotGranted = status.New(codes.FailedPrecondition, "etcdserver: permission is not granted to the role").Err()
+	ErrGRPCAuthNotEnabled       = status.New(codes.FailedPrecondition, "etcdserver: authentication is not enabled").Err()
+	ErrGRPCInvalidAuthToken     = status.New(codes.Unauthenticated, "etcdserver: invalid auth token").Err()
+	ErrGRPCInvalidAuthMgmt      = status.New(codes.InvalidArgument, "etcdserver: invalid auth management").Err()
+
+	ErrGRPCNoLeader                   = status.New(codes.Unavailable, "etcdserver: no leader").Err()
+	ErrGRPCNotLeader                  = status.New(codes.FailedPrecondition, "etcdserver: not leader").Err()
+	ErrGRPCNotCapable                 = status.New(codes.Unavailable, "etcdserver: not capable").Err()
+	ErrGRPCStopped                    = status.New(codes.Unavailable, "etcdserver: server stopped").Err()
+	ErrGRPCTimeout                    = status.New(codes.Unavailable, "etcdserver: request timed out").Err()
+	ErrGRPCTimeoutDueToLeaderFail     = status.New(codes.Unavailable, "etcdserver: request timed out, possibly due to previous leader failure").Err()
+	ErrGRPCTimeoutDueToConnectionLost = status.New(codes.Unavailable, "etcdserver: request timed out, possibly due to connection lost").Err()
+	ErrGRPCUnhealthy                  = status.New(codes.Unavailable, "etcdserver: unhealthy cluster").Err()
+	ErrGRPCCorrupt                    = status.New(codes.DataLoss, "etcdserver: corrupt cluster").Err()
+
+	errStringToError = map[string]error{
+		ErrorDesc(ErrGRPCEmptyKey):      ErrGRPCEmptyKey,
+		ErrorDesc(ErrGRPCKeyNotFound):   ErrGRPCKeyNotFound,
+		ErrorDesc(ErrGRPCValueProvided): ErrGRPCValueProvided,
+		ErrorDesc(ErrGRPCLeaseProvided): ErrGRPCLeaseProvided,
+
+		ErrorDesc(ErrGRPCTooManyOps):   ErrGRPCTooManyOps,
+		ErrorDesc(ErrGRPCDuplicateKey): ErrGRPCDuplicateKey,
+		ErrorDesc(ErrGRPCCompacted):    ErrGRPCCompacted,
+		ErrorDesc(ErrGRPCFutureRev):    ErrGRPCFutureRev,
+		ErrorDesc(ErrGRPCNoSpace):      ErrGRPCNoSpace,
+
+		ErrorDesc(ErrGRPCLeaseNotFound): ErrGRPCLeaseNotFound,
+		ErrorDesc(ErrGRPCLeaseExist):    ErrGRPCLeaseExist,
+
+		ErrorDesc(ErrGRPCMemberExist):            ErrGRPCMemberExist,
+		ErrorDesc(ErrGRPCPeerURLExist):           ErrGRPCPeerURLExist,
+		ErrorDesc(ErrGRPCMemberNotEnoughStarted): ErrGRPCMemberNotEnoughStarted,
+		ErrorDesc(ErrGRPCMemberBadURLs):          ErrGRPCMemberBadURLs,
+		ErrorDesc(ErrGRPCMemberNotFound):         ErrGRPCMemberNotFound,
+
+		ErrorDesc(ErrGRPCRequestTooLarge):        ErrGRPCRequestTooLarge,
+		ErrorDesc(ErrGRPCRequestTooManyRequests): ErrGRPCRequestTooManyRequests,
+
+		ErrorDesc(ErrGRPCRootUserNotExist):     ErrGRPCRootUserNotExist,
+		ErrorDesc(ErrGRPCRootRoleNotExist):     ErrGRPCRootRoleNotExist,
+		ErrorDesc(ErrGRPCUserAlreadyExist):     ErrGRPCUserAlreadyExist,
+		ErrorDesc(ErrGRPCUserEmpty):            ErrGRPCUserEmpty,
+		ErrorDesc(ErrGRPCUserNotFound):         ErrGRPCUserNotFound,
+		ErrorDesc(ErrGRPCRoleAlreadyExist):     ErrGRPCRoleAlreadyExist,
+		ErrorDesc(ErrGRPCRoleNotFound):         ErrGRPCRoleNotFound,
+		ErrorDesc(ErrGRPCAuthFailed):           ErrGRPCAuthFailed,
+		ErrorDesc(ErrGRPCPermissionDenied):     ErrGRPCPermissionDenied,
+		ErrorDesc(ErrGRPCRoleNotGranted):       ErrGRPCRoleNotGranted,
+		ErrorDesc(ErrGRPCPermissionNotGranted): ErrGRPCPermissionNotGranted,
+		ErrorDesc(ErrGRPCAuthNotEnabled):       ErrGRPCAuthNotEnabled,
+		ErrorDesc(ErrGRPCInvalidAuthToken):     ErrGRPCInvalidAuthToken,
+		ErrorDesc(ErrGRPCInvalidAuthMgmt):      ErrGRPCInvalidAuthMgmt,
+
+		ErrorDesc(ErrGRPCNoLeader):                   ErrGRPCNoLeader,
+		ErrorDesc(ErrGRPCNotLeader):                  ErrGRPCNotLeader,
+		ErrorDesc(ErrGRPCNotCapable):                 ErrGRPCNotCapable,
+		ErrorDesc(ErrGRPCStopped):                    ErrGRPCStopped,
+		ErrorDesc(ErrGRPCTimeout):                    ErrGRPCTimeout,
+		ErrorDesc(ErrGRPCTimeoutDueToLeaderFail):     ErrGRPCTimeoutDueToLeaderFail,
+		ErrorDesc(ErrGRPCTimeoutDueToConnectionLost): ErrGRPCTimeoutDueToConnectionLost,
+		ErrorDesc(ErrGRPCUnhealthy):                  ErrGRPCUnhealthy,
+		ErrorDesc(ErrGRPCCorrupt):                    ErrGRPCCorrupt,
+	}
+)
+
+// client-side error
+var (
+	ErrEmptyKey      = Error(ErrGRPCEmptyKey)
+	ErrKeyNotFound   = Error(ErrGRPCKeyNotFound)
+	ErrValueProvided = Error(ErrGRPCValueProvided)
+	ErrLeaseProvided = Error(ErrGRPCLeaseProvided)
+	ErrTooManyOps    = Error(ErrGRPCTooManyOps)
+	ErrDuplicateKey  = Error(ErrGRPCDuplicateKey)
+	ErrCompacted     = Error(ErrGRPCCompacted)
+	ErrFutureRev     = Error(ErrGRPCFutureRev)
+	ErrNoSpace       = Error(ErrGRPCNoSpace)
+
+	ErrLeaseNotFound = Error(ErrGRPCLeaseNotFound)
+	ErrLeaseExist    = Error(ErrGRPCLeaseExist)
+
+	ErrMemberExist            = Error(ErrGRPCMemberExist)
+	ErrPeerURLExist           = Error(ErrGRPCPeerURLExist)
+	ErrMemberNotEnoughStarted = Error(ErrGRPCMemberNotEnoughStarted)
+	ErrMemberBadURLs          = Error(ErrGRPCMemberBadURLs)
+	ErrMemberNotFound         = Error(ErrGRPCMemberNotFound)
+
+	ErrRequestTooLarge = Error(ErrGRPCRequestTooLarge)
+	ErrTooManyRequests = Error(ErrGRPCRequestTooManyRequests)
+
+	ErrRootUserNotExist     = Error(ErrGRPCRootUserNotExist)
+	ErrRootRoleNotExist     = Error(ErrGRPCRootRoleNotExist)
+	ErrUserAlreadyExist     = Error(ErrGRPCUserAlreadyExist)
+	ErrUserEmpty            = Error(ErrGRPCUserEmpty)
+	ErrUserNotFound         = Error(ErrGRPCUserNotFound)
+	ErrRoleAlreadyExist     = Error(ErrGRPCRoleAlreadyExist)
+	ErrRoleNotFound         = Error(ErrGRPCRoleNotFound)
+	ErrAuthFailed           = Error(ErrGRPCAuthFailed)
+	ErrPermissionDenied     = Error(ErrGRPCPermissionDenied)
+	ErrRoleNotGranted       = Error(ErrGRPCRoleNotGranted)
+	ErrPermissionNotGranted = Error(ErrGRPCPermissionNotGranted)
+	ErrAuthNotEnabled       = Error(ErrGRPCAuthNotEnabled)
+	ErrInvalidAuthToken     = Error(ErrGRPCInvalidAuthToken)
+	ErrInvalidAuthMgmt      = Error(ErrGRPCInvalidAuthMgmt)
+
+	ErrNoLeader                   = Error(ErrGRPCNoLeader)
+	ErrNotLeader                  = Error(ErrGRPCNotLeader)
+	ErrNotCapable                 = Error(ErrGRPCNotCapable)
+	ErrStopped                    = Error(ErrGRPCStopped)
+	ErrTimeout                    = Error(ErrGRPCTimeout)
+	ErrTimeoutDueToLeaderFail     = Error(ErrGRPCTimeoutDueToLeaderFail)
+	ErrTimeoutDueToConnectionLost = Error(ErrGRPCTimeoutDueToConnectionLost)
+	ErrUnhealthy                  = Error(ErrGRPCUnhealthy)
+	ErrCorrupt                    = Error(ErrGRPCCorrupt)
+)
+
+// EtcdError defines gRPC server errors.
+// (https://github.com/grpc/grpc-go/blob/master/rpc_util.go#L319-L323)
+type EtcdError struct {
+	code codes.Code
+	desc string
+}
+
+// Code returns grpc/codes.Code.
+// TODO: define clientv3/codes.Code.
+func (e EtcdError) Code() codes.Code {
+	return e.code
+}
+
+func (e EtcdError) Error() string {
+	return e.desc
+}
+
+func Error(err error) error {
+	if err == nil {
+		return nil
+	}
+	verr, ok := errStringToError[ErrorDesc(err)]
+	if !ok { // not gRPC error
+		return err
+	}
+	ev, ok := status.FromError(verr)
+	var desc string
+	if ok {
+		desc = ev.Message()
+	} else {
+		desc = verr.Error()
+	}
+	return EtcdError{code: ev.Code(), desc: desc}
+}
+
+func ErrorDesc(err error) string {
+	if s, ok := status.FromError(err); ok {
+		return s.Message()
+	}
+	return err.Error()
+}
diff --git a/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/md.go b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/md.go
new file mode 100644
index 000000000..5c590e1ae
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes/md.go
@@ -0,0 +1,20 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package rpctypes
+
+var (
+	MetadataRequireLeaderKey = "hasleader"
+	MetadataHasLeader        = "true"
+)
diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/etcdserver.pb.go b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/etcdserver.pb.go
new file mode 100644
index 000000000..e4007f5de
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/etcdserver.pb.go
@@ -0,0 +1,1052 @@
+// Code generated by protoc-gen-gogo.
+// source: etcdserver.proto
+// DO NOT EDIT!
+
+/*
+	Package etcdserverpb is a generated protocol buffer package.
+
+	It is generated from these files:
+		etcdserver.proto
+		raft_internal.proto
+		rpc.proto
+
+	It has these top-level messages:
+		Request
+		Metadata
+		RequestHeader
+		InternalRaftRequest
+		EmptyResponse
+		InternalAuthenticateRequest
+		ResponseHeader
+		RangeRequest
+		RangeResponse
+		PutRequest
+		PutResponse
+		DeleteRangeRequest
+		DeleteRangeResponse
+		RequestOp
+		ResponseOp
+		Compare
+		TxnRequest
+		TxnResponse
+		CompactionRequest
+		CompactionResponse
+		HashRequest
+		HashKVRequest
+		HashKVResponse
+		HashResponse
+		SnapshotRequest
+		SnapshotResponse
+		WatchRequest
+		WatchCreateRequest
+		WatchCancelRequest
+		WatchResponse
+		LeaseGrantRequest
+		LeaseGrantResponse
+		LeaseRevokeRequest
+		LeaseRevokeResponse
+		LeaseKeepAliveRequest
+		LeaseKeepAliveResponse
+		LeaseTimeToLiveRequest
+		LeaseTimeToLiveResponse
+		LeaseLeasesRequest
+		LeaseStatus
+		LeaseLeasesResponse
+		Member
+		MemberAddRequest
+		MemberAddResponse
+		MemberRemoveRequest
+		MemberRemoveResponse
+		MemberUpdateRequest
+		MemberUpdateResponse
+		MemberListRequest
+		MemberListResponse
+		DefragmentRequest
+		DefragmentResponse
+		MoveLeaderRequest
+		MoveLeaderResponse
+		AlarmRequest
+		AlarmMember
+		AlarmResponse
+		StatusRequest
+		StatusResponse
+		AuthEnableRequest
+		AuthDisableRequest
+		AuthenticateRequest
+		AuthUserAddRequest
+		AuthUserGetRequest
+		AuthUserDeleteRequest
+		AuthUserChangePasswordRequest
+		AuthUserGrantRoleRequest
+		AuthUserRevokeRoleRequest
+		AuthRoleAddRequest
+		AuthRoleGetRequest
+		AuthUserListRequest
+		AuthRoleListRequest
+		AuthRoleDeleteRequest
+		AuthRoleGrantPermissionRequest
+		AuthRoleRevokePermissionRequest
+		AuthEnableResponse
+		AuthDisableResponse
+		AuthenticateResponse
+		AuthUserAddResponse
+		AuthUserGetResponse
+		AuthUserDeleteResponse
+		AuthUserChangePasswordResponse
+		AuthUserGrantRoleResponse
+		AuthUserRevokeRoleResponse
+		AuthRoleAddResponse
+		AuthRoleGetResponse
+		AuthRoleListResponse
+		AuthUserListResponse
+		AuthRoleDeleteResponse
+		AuthRoleGrantPermissionResponse
+		AuthRoleRevokePermissionResponse
+*/
+package etcdserverpb
+
+import (
+	"fmt"
+
+	proto "github.com/golang/protobuf/proto"
+
+	math "math"
+
+	io "io"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type Request struct {
+	ID               uint64 `protobuf:"varint,1,opt,name=ID" json:"ID"`
+	Method           string `protobuf:"bytes,2,opt,name=Method" json:"Method"`
+	Path             string `protobuf:"bytes,3,opt,name=Path" json:"Path"`
+	Val              string `protobuf:"bytes,4,opt,name=Val" json:"Val"`
+	Dir              bool   `protobuf:"varint,5,opt,name=Dir" json:"Dir"`
+	PrevValue        string `protobuf:"bytes,6,opt,name=PrevValue" json:"PrevValue"`
+	PrevIndex        uint64 `protobuf:"varint,7,opt,name=PrevIndex" json:"PrevIndex"`
+	PrevExist        *bool  `protobuf:"varint,8,opt,name=PrevExist" json:"PrevExist,omitempty"`
+	Expiration       int64  `protobuf:"varint,9,opt,name=Expiration" json:"Expiration"`
+	Wait             bool   `protobuf:"varint,10,opt,name=Wait" json:"Wait"`
+	Since            uint64 `protobuf:"varint,11,opt,name=Since" json:"Since"`
+	Recursive        bool   `protobuf:"varint,12,opt,name=Recursive" json:"Recursive"`
+	Sorted           bool   `protobuf:"varint,13,opt,name=Sorted" json:"Sorted"`
+	Quorum           bool   `protobuf:"varint,14,opt,name=Quorum" json:"Quorum"`
+	Time             int64  `protobuf:"varint,15,opt,name=Time" json:"Time"`
+	Stream           bool   `protobuf:"varint,16,opt,name=Stream" json:"Stream"`
+	Refresh          *bool  `protobuf:"varint,17,opt,name=Refresh" json:"Refresh,omitempty"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *Request) Reset()                    { *m = Request{} }
+func (m *Request) String() string            { return proto.CompactTextString(m) }
+func (*Request) ProtoMessage()               {}
+func (*Request) Descriptor() ([]byte, []int) { return fileDescriptorEtcdserver, []int{0} }
+
+type Metadata struct {
+	NodeID           uint64 `protobuf:"varint,1,opt,name=NodeID" json:"NodeID"`
+	ClusterID        uint64 `protobuf:"varint,2,opt,name=ClusterID" json:"ClusterID"`
+	XXX_unrecognized []byte `json:"-"`
+}
+
+func (m *Metadata) Reset()                    { *m = Metadata{} }
+func (m *Metadata) String() string            { return proto.CompactTextString(m) }
+func (*Metadata) ProtoMessage()               {}
+func (*Metadata) Descriptor() ([]byte, []int) { return fileDescriptorEtcdserver, []int{1} }
+
+func init() {
+	proto.RegisterType((*Request)(nil), "etcdserverpb.Request")
+	proto.RegisterType((*Metadata)(nil), "etcdserverpb.Metadata")
+}
+func (m *Request) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Request) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	dAtA[i] = 0x8
+	i++
+	i = encodeVarintEtcdserver(dAtA, i, uint64(m.ID))
+	dAtA[i] = 0x12
+	i++
+	i = encodeVarintEtcdserver(dAtA, i, uint64(len(m.Method)))
+	i += copy(dAtA[i:], m.Method)
+	dAtA[i] = 0x1a
+	i++
+	i = encodeVarintEtcdserver(dAtA, i, uint64(len(m.Path)))
+	i += copy(dAtA[i:], m.Path)
+	dAtA[i] = 0x22
+	i++
+	i = encodeVarintEtcdserver(dAtA, i, uint64(len(m.Val)))
+	i += copy(dAtA[i:], m.Val)
+	dAtA[i] = 0x28
+	i++
+	if m.Dir {
+		dAtA[i] = 1
+	} else {
+		dAtA[i] = 0
+	}
+	i++
+	dAtA[i] = 0x32
+	i++
+	i = encodeVarintEtcdserver(dAtA, i, uint64(len(m.PrevValue)))
+	i += copy(dAtA[i:], m.PrevValue)
+	dAtA[i] = 0x38
+	i++
+	i = encodeVarintEtcdserver(dAtA, i, uint64(m.PrevIndex))
+	if m.PrevExist != nil {
+		dAtA[i] = 0x40
+		i++
+		if *m.PrevExist {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	dAtA[i] = 0x48
+	i++
+	i = encodeVarintEtcdserver(dAtA, i, uint64(m.Expiration))
+	dAtA[i] = 0x50
+	i++
+	if m.Wait {
+		dAtA[i] = 1
+	} else {
+		dAtA[i] = 0
+	}
+	i++
+	dAtA[i] = 0x58
+	i++
+	i = encodeVarintEtcdserver(dAtA, i, uint64(m.Since))
+	dAtA[i] = 0x60
+	i++
+	if m.Recursive {
+		dAtA[i] = 1
+	} else {
+		dAtA[i] = 0
+	}
+	i++
+	dAtA[i] = 0x68
+	i++
+	if m.Sorted {
+		dAtA[i] = 1
+	} else {
+		dAtA[i] = 0
+	}
+	i++
+	dAtA[i] = 0x70
+	i++
+	if m.Quorum {
+		dAtA[i] = 1
+	} else {
+		dAtA[i] = 0
+	}
+	i++
+	dAtA[i] = 0x78
+	i++
+	i = encodeVarintEtcdserver(dAtA, i, uint64(m.Time))
+	dAtA[i] = 0x80
+	i++
+	dAtA[i] = 0x1
+	i++
+	if m.Stream {
+		dAtA[i] = 1
+	} else {
+		dAtA[i] = 0
+	}
+	i++
+	if m.Refresh != nil {
+		dAtA[i] = 0x88
+		i++
+		dAtA[i] = 0x1
+		i++
+		if *m.Refresh {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func (m *Metadata) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Metadata) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	dAtA[i] = 0x8
+	i++
+	i = encodeVarintEtcdserver(dAtA, i, uint64(m.NodeID))
+	dAtA[i] = 0x10
+	i++
+	i = encodeVarintEtcdserver(dAtA, i, uint64(m.ClusterID))
+	if m.XXX_unrecognized != nil {
+		i += copy(dAtA[i:], m.XXX_unrecognized)
+	}
+	return i, nil
+}
+
+func encodeFixed64Etcdserver(dAtA []byte, offset int, v uint64) int {
+	dAtA[offset] = uint8(v)
+	dAtA[offset+1] = uint8(v >> 8)
+	dAtA[offset+2] = uint8(v >> 16)
+	dAtA[offset+3] = uint8(v >> 24)
+	dAtA[offset+4] = uint8(v >> 32)
+	dAtA[offset+5] = uint8(v >> 40)
+	dAtA[offset+6] = uint8(v >> 48)
+	dAtA[offset+7] = uint8(v >> 56)
+	return offset + 8
+}
+func encodeFixed32Etcdserver(dAtA []byte, offset int, v uint32) int {
+	dAtA[offset] = uint8(v)
+	dAtA[offset+1] = uint8(v >> 8)
+	dAtA[offset+2] = uint8(v >> 16)
+	dAtA[offset+3] = uint8(v >> 24)
+	return offset + 4
+}
+func encodeVarintEtcdserver(dAtA []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return offset + 1
+}
+func (m *Request) Size() (n int) {
+	var l int
+	_ = l
+	n += 1 + sovEtcdserver(uint64(m.ID))
+	l = len(m.Method)
+	n += 1 + l + sovEtcdserver(uint64(l))
+	l = len(m.Path)
+	n += 1 + l + sovEtcdserver(uint64(l))
+	l = len(m.Val)
+	n += 1 + l + sovEtcdserver(uint64(l))
+	n += 2
+	l = len(m.PrevValue)
+	n += 1 + l + sovEtcdserver(uint64(l))
+	n += 1 + sovEtcdserver(uint64(m.PrevIndex))
+	if m.PrevExist != nil {
+		n += 2
+	}
+	n += 1 + sovEtcdserver(uint64(m.Expiration))
+	n += 2
+	n += 1 + sovEtcdserver(uint64(m.Since))
+	n += 2
+	n += 2
+	n += 2
+	n += 1 + sovEtcdserver(uint64(m.Time))
+	n += 3
+	if m.Refresh != nil {
+		n += 3
+	}
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func (m *Metadata) Size() (n int) {
+	var l int
+	_ = l
+	n += 1 + sovEtcdserver(uint64(m.NodeID))
+	n += 1 + sovEtcdserver(uint64(m.ClusterID))
+	if m.XXX_unrecognized != nil {
+		n += len(m.XXX_unrecognized)
+	}
+	return n
+}
+
+func sovEtcdserver(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozEtcdserver(x uint64) (n int) {
+	return sovEtcdserver(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *Request) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowEtcdserver
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Request: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Request: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Method", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthEtcdserver
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Method = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Path", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthEtcdserver
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Path = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Val", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthEtcdserver
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Val = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Dir", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Dir = bool(v != 0)
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PrevValue", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthEtcdserver
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PrevValue = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 7:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PrevIndex", wireType)
+			}
+			m.PrevIndex = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.PrevIndex |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PrevExist", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			b := bool(v != 0)
+			m.PrevExist = &b
+		case 9:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Expiration", wireType)
+			}
+			m.Expiration = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Expiration |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 10:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Wait", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Wait = bool(v != 0)
+		case 11:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Since", wireType)
+			}
+			m.Since = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Since |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 12:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Recursive", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Recursive = bool(v != 0)
+		case 13:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Sorted", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Sorted = bool(v != 0)
+		case 14:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Quorum", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Quorum = bool(v != 0)
+		case 15:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Time", wireType)
+			}
+			m.Time = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Time |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 16:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Stream", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Stream = bool(v != 0)
+		case 17:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Refresh", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			b := bool(v != 0)
+			m.Refresh = &b
+		default:
+			iNdEx = preIndex
+			skippy, err := skipEtcdserver(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthEtcdserver
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Metadata) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowEtcdserver
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Metadata: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Metadata: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field NodeID", wireType)
+			}
+			m.NodeID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.NodeID |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ClusterID", wireType)
+			}
+			m.ClusterID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ClusterID |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipEtcdserver(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthEtcdserver
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.XXX_unrecognized = append(m.XXX_unrecognized, dAtA[iNdEx:iNdEx+skippy]...)
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipEtcdserver(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowEtcdserver
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowEtcdserver
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			iNdEx += length
+			if length < 0 {
+				return 0, ErrInvalidLengthEtcdserver
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowEtcdserver
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipEtcdserver(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthEtcdserver = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowEtcdserver   = fmt.Errorf("proto: integer overflow")
+)
+
+func init() { proto.RegisterFile("etcdserver.proto", fileDescriptorEtcdserver) }
+
+var fileDescriptorEtcdserver = []byte{
+	// 380 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x5c, 0xd2, 0xdd, 0x6e, 0xda, 0x30,
+	0x14, 0x07, 0x70, 0x0c, 0xe1, 0xcb, 0x63, 0x1b, 0xb3, 0xd0, 0x74, 0x84, 0xa6, 0x2c, 0x42, 0xbb,
+	0xc8, 0xd5, 0xf6, 0x0e, 0x2c, 0x5c, 0x44, 0x2a, 0x15, 0x0d, 0x15, 0xbd, 0x76, 0xc9, 0x29, 0x58,
+	0x02, 0x4c, 0x1d, 0x07, 0xf1, 0x06, 0x7d, 0x85, 0x3e, 0x12, 0x97, 0x7d, 0x82, 0xaa, 0xa5, 0x2f,
+	0x52, 0x39, 0x24, 0xc4, 0xed, 0x5d, 0xf4, 0xfb, 0x9f, 0x1c, 0x1f, 0x7f, 0xd0, 0x2e, 0xea, 0x79,
+	0x9c, 0xa0, 0xda, 0xa1, 0xfa, 0xbb, 0x55, 0x52, 0x4b, 0xd6, 0x29, 0x65, 0x7b, 0xdb, 0xef, 0x2d,
+	0xe4, 0x42, 0x66, 0xc1, 0x3f, 0xf3, 0x75, 0xaa, 0x19, 0x3c, 0x38, 0xb4, 0x19, 0xe1, 0x7d, 0x8a,
+	0x89, 0x66, 0x3d, 0x5a, 0x0d, 0x03, 0x20, 0x1e, 0xf1, 0x9d, 0xa1, 0x73, 0x78, 0xfe, 0x5d, 0x89,
+	0xaa, 0x61, 0xc0, 0x7e, 0xd1, 0xc6, 0x18, 0xf5, 0x52, 0xc6, 0x50, 0xf5, 0x88, 0xdf, 0xce, 0x93,
+	0xdc, 0x18, 0x50, 0x67, 0xc2, 0xf5, 0x12, 0x6a, 0x56, 0x96, 0x09, 0xfb, 0x49, 0x6b, 0x33, 0xbe,
+	0x02, 0xc7, 0x0a, 0x0c, 0x18, 0x0f, 0x84, 0x82, 0xba, 0x47, 0xfc, 0x56, 0xe1, 0x81, 0x50, 0x6c,
+	0x40, 0xdb, 0x13, 0x85, 0xbb, 0x19, 0x5f, 0xa5, 0x08, 0x0d, 0xeb, 0xaf, 0x92, 0x8b, 0x9a, 0x70,
+	0x13, 0xe3, 0x1e, 0x9a, 0xd6, 0xa0, 0x25, 0x17, 0x35, 0xa3, 0xbd, 0x48, 0x34, 0xb4, 0xce, 0xab,
+	0x90, 0xa8, 0x64, 0xf6, 0x87, 0xd2, 0xd1, 0x7e, 0x2b, 0x14, 0xd7, 0x42, 0x6e, 0xa0, 0xed, 0x11,
+	0xbf, 0x96, 0x37, 0xb2, 0xdc, 0xec, 0xed, 0x86, 0x0b, 0x0d, 0xd4, 0x1a, 0x35, 0x13, 0xd6, 0xa7,
+	0xf5, 0xa9, 0xd8, 0xcc, 0x11, 0xbe, 0x58, 0x33, 0x9c, 0xc8, 0xac, 0x1f, 0xe1, 0x3c, 0x55, 0x89,
+	0xd8, 0x21, 0x74, 0xac, 0x5f, 0x4b, 0x36, 0x67, 0x3a, 0x95, 0x4a, 0x63, 0x0c, 0x5f, 0xad, 0x82,
+	0xdc, 0x4c, 0x7a, 0x95, 0x4a, 0x95, 0xae, 0xe1, 0x9b, 0x9d, 0x9e, 0xcc, 0x4c, 0x75, 0x2d, 0xd6,
+	0x08, 0xdf, 0xad, 0xa9, 0x33, 0xc9, 0xba, 0x6a, 0x85, 0x7c, 0x0d, 0xdd, 0x0f, 0x5d, 0x33, 0x63,
+	0xae, 0xb9, 0xe8, 0x3b, 0x85, 0xc9, 0x12, 0x7e, 0x58, 0xa7, 0x52, 0xe0, 0xe0, 0x82, 0xb6, 0xc6,
+	0xa8, 0x79, 0xcc, 0x35, 0x37, 0x9d, 0x2e, 0x65, 0x8c, 0x9f, 0x5e, 0x43, 0x6e, 0x66, 0x87, 0xff,
+	0x57, 0x69, 0xa2, 0x51, 0x85, 0x41, 0xf6, 0x28, 0xce, 0xb7, 0x70, 0xe6, 0x61, 0xef, 0xf0, 0xea,
+	0x56, 0x0e, 0x47, 0x97, 0x3c, 0x1d, 0x5d, 0xf2, 0x72, 0x74, 0xc9, 0xe3, 0x9b, 0x5b, 0x79, 0x0f,
+	0x00, 0x00, 0xff, 0xff, 0xee, 0x40, 0xba, 0xd6, 0xa4, 0x02, 0x00, 0x00,
+}
diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/etcdserver.proto b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/etcdserver.proto
new file mode 100644
index 000000000..25e0aca5d
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/etcdserver.proto
@@ -0,0 +1,34 @@
+syntax = "proto2";
+package etcdserverpb;
+
+import "gogoproto/gogo.proto";
+
+option (gogoproto.marshaler_all) = true;
+option (gogoproto.sizer_all) = true;
+option (gogoproto.unmarshaler_all) = true;
+option (gogoproto.goproto_getters_all) = false;
+
+message Request {
+	optional uint64 ID         =  1 [(gogoproto.nullable) = false];
+	optional string Method     =  2 [(gogoproto.nullable) = false];
+	optional string Path       =  3 [(gogoproto.nullable) = false];
+	optional string Val        =  4 [(gogoproto.nullable) = false];
+	optional bool   Dir        =  5 [(gogoproto.nullable) = false];
+	optional string PrevValue  =  6 [(gogoproto.nullable) = false];
+	optional uint64 PrevIndex  =  7 [(gogoproto.nullable) = false];
+	optional bool   PrevExist  =  8 [(gogoproto.nullable) = true];
+	optional int64  Expiration =  9 [(gogoproto.nullable) = false];
+	optional bool   Wait       = 10 [(gogoproto.nullable) = false];
+	optional uint64 Since      = 11 [(gogoproto.nullable) = false];
+	optional bool   Recursive  = 12 [(gogoproto.nullable) = false];
+	optional bool   Sorted     = 13 [(gogoproto.nullable) = false];
+	optional bool   Quorum     = 14 [(gogoproto.nullable) = false];
+	optional int64  Time       = 15 [(gogoproto.nullable) = false];
+	optional bool   Stream     = 16 [(gogoproto.nullable) = false];
+	optional bool   Refresh    = 17 [(gogoproto.nullable) = true];
+}
+
+message Metadata {
+	optional uint64 NodeID    = 1 [(gogoproto.nullable) = false];
+	optional uint64 ClusterID = 2 [(gogoproto.nullable) = false];
+}
diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal.pb.go b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal.pb.go
new file mode 100644
index 000000000..44a3b6f69
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal.pb.go
@@ -0,0 +1,2094 @@
+// Code generated by protoc-gen-gogo.
+// source: raft_internal.proto
+// DO NOT EDIT!
+
+package etcdserverpb
+
+import (
+	"fmt"
+
+	proto "github.com/golang/protobuf/proto"
+
+	math "math"
+
+	io "io"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type RequestHeader struct {
+	ID uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
+	// username is a username that is associated with an auth token of gRPC connection
+	Username string `protobuf:"bytes,2,opt,name=username,proto3" json:"username,omitempty"`
+	// auth_revision is a revision number of auth.authStore. It is not related to mvcc
+	AuthRevision uint64 `protobuf:"varint,3,opt,name=auth_revision,json=authRevision,proto3" json:"auth_revision,omitempty"`
+}
+
+func (m *RequestHeader) Reset()                    { *m = RequestHeader{} }
+func (m *RequestHeader) String() string            { return proto.CompactTextString(m) }
+func (*RequestHeader) ProtoMessage()               {}
+func (*RequestHeader) Descriptor() ([]byte, []int) { return fileDescriptorRaftInternal, []int{0} }
+
+// An InternalRaftRequest is the union of all requests which can be
+// sent via raft.
+type InternalRaftRequest struct {
+	Header                   *RequestHeader                   `protobuf:"bytes,100,opt,name=header" json:"header,omitempty"`
+	ID                       uint64                           `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
+	V2                       *Request                         `protobuf:"bytes,2,opt,name=v2" json:"v2,omitempty"`
+	Range                    *RangeRequest                    `protobuf:"bytes,3,opt,name=range" json:"range,omitempty"`
+	Put                      *PutRequest                      `protobuf:"bytes,4,opt,name=put" json:"put,omitempty"`
+	DeleteRange              *DeleteRangeRequest              `protobuf:"bytes,5,opt,name=delete_range,json=deleteRange" json:"delete_range,omitempty"`
+	Txn                      *TxnRequest                      `protobuf:"bytes,6,opt,name=txn" json:"txn,omitempty"`
+	Compaction               *CompactionRequest               `protobuf:"bytes,7,opt,name=compaction" json:"compaction,omitempty"`
+	LeaseGrant               *LeaseGrantRequest               `protobuf:"bytes,8,opt,name=lease_grant,json=leaseGrant" json:"lease_grant,omitempty"`
+	LeaseRevoke              *LeaseRevokeRequest              `protobuf:"bytes,9,opt,name=lease_revoke,json=leaseRevoke" json:"lease_revoke,omitempty"`
+	Alarm                    *AlarmRequest                    `protobuf:"bytes,10,opt,name=alarm" json:"alarm,omitempty"`
+	AuthEnable               *AuthEnableRequest               `protobuf:"bytes,1000,opt,name=auth_enable,json=authEnable" json:"auth_enable,omitempty"`
+	AuthDisable              *AuthDisableRequest              `protobuf:"bytes,1011,opt,name=auth_disable,json=authDisable" json:"auth_disable,omitempty"`
+	Authenticate             *InternalAuthenticateRequest     `protobuf:"bytes,1012,opt,name=authenticate" json:"authenticate,omitempty"`
+	AuthUserAdd              *AuthUserAddRequest              `protobuf:"bytes,1100,opt,name=auth_user_add,json=authUserAdd" json:"auth_user_add,omitempty"`
+	AuthUserDelete           *AuthUserDeleteRequest           `protobuf:"bytes,1101,opt,name=auth_user_delete,json=authUserDelete" json:"auth_user_delete,omitempty"`
+	AuthUserGet              *AuthUserGetRequest              `protobuf:"bytes,1102,opt,name=auth_user_get,json=authUserGet" json:"auth_user_get,omitempty"`
+	AuthUserChangePassword   *AuthUserChangePasswordRequest   `protobuf:"bytes,1103,opt,name=auth_user_change_password,json=authUserChangePassword" json:"auth_user_change_password,omitempty"`
+	AuthUserGrantRole        *AuthUserGrantRoleRequest        `protobuf:"bytes,1104,opt,name=auth_user_grant_role,json=authUserGrantRole" json:"auth_user_grant_role,omitempty"`
+	AuthUserRevokeRole       *AuthUserRevokeRoleRequest       `protobuf:"bytes,1105,opt,name=auth_user_revoke_role,json=authUserRevokeRole" json:"auth_user_revoke_role,omitempty"`
+	AuthUserList             *AuthUserListRequest             `protobuf:"bytes,1106,opt,name=auth_user_list,json=authUserList" json:"auth_user_list,omitempty"`
+	AuthRoleList             *AuthRoleListRequest             `protobuf:"bytes,1107,opt,name=auth_role_list,json=authRoleList" json:"auth_role_list,omitempty"`
+	AuthRoleAdd              *AuthRoleAddRequest              `protobuf:"bytes,1200,opt,name=auth_role_add,json=authRoleAdd" json:"auth_role_add,omitempty"`
+	AuthRoleDelete           *AuthRoleDeleteRequest           `protobuf:"bytes,1201,opt,name=auth_role_delete,json=authRoleDelete" json:"auth_role_delete,omitempty"`
+	AuthRoleGet              *AuthRoleGetRequest              `protobuf:"bytes,1202,opt,name=auth_role_get,json=authRoleGet" json:"auth_role_get,omitempty"`
+	AuthRoleGrantPermission  *AuthRoleGrantPermissionRequest  `protobuf:"bytes,1203,opt,name=auth_role_grant_permission,json=authRoleGrantPermission" json:"auth_role_grant_permission,omitempty"`
+	AuthRoleRevokePermission *AuthRoleRevokePermissionRequest `protobuf:"bytes,1204,opt,name=auth_role_revoke_permission,json=authRoleRevokePermission" json:"auth_role_revoke_permission,omitempty"`
+}
+
+func (m *InternalRaftRequest) Reset()                    { *m = InternalRaftRequest{} }
+func (m *InternalRaftRequest) String() string            { return proto.CompactTextString(m) }
+func (*InternalRaftRequest) ProtoMessage()               {}
+func (*InternalRaftRequest) Descriptor() ([]byte, []int) { return fileDescriptorRaftInternal, []int{1} }
+
+type EmptyResponse struct {
+}
+
+func (m *EmptyResponse) Reset()                    { *m = EmptyResponse{} }
+func (m *EmptyResponse) String() string            { return proto.CompactTextString(m) }
+func (*EmptyResponse) ProtoMessage()               {}
+func (*EmptyResponse) Descriptor() ([]byte, []int) { return fileDescriptorRaftInternal, []int{2} }
+
+// What is the difference between AuthenticateRequest (defined in rpc.proto) and InternalAuthenticateRequest?
+// InternalAuthenticateRequest has a member that is filled by etcdserver and shouldn't be user-facing.
+// For avoiding misusage the field, we have an internal version of AuthenticateRequest.
+type InternalAuthenticateRequest struct {
+	Name     string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
+	// simple_token is generated in API layer (etcdserver/v3_server.go)
+	SimpleToken string `protobuf:"bytes,3,opt,name=simple_token,json=simpleToken,proto3" json:"simple_token,omitempty"`
+}
+
+func (m *InternalAuthenticateRequest) Reset()         { *m = InternalAuthenticateRequest{} }
+func (m *InternalAuthenticateRequest) String() string { return proto.CompactTextString(m) }
+func (*InternalAuthenticateRequest) ProtoMessage()    {}
+func (*InternalAuthenticateRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptorRaftInternal, []int{3}
+}
+
+func init() {
+	proto.RegisterType((*RequestHeader)(nil), "etcdserverpb.RequestHeader")
+	proto.RegisterType((*InternalRaftRequest)(nil), "etcdserverpb.InternalRaftRequest")
+	proto.RegisterType((*EmptyResponse)(nil), "etcdserverpb.EmptyResponse")
+	proto.RegisterType((*InternalAuthenticateRequest)(nil), "etcdserverpb.InternalAuthenticateRequest")
+}
+func (m *RequestHeader) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *RequestHeader) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.ID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.ID))
+	}
+	if len(m.Username) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(len(m.Username)))
+		i += copy(dAtA[i:], m.Username)
+	}
+	if m.AuthRevision != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthRevision))
+	}
+	return i, nil
+}
+
+func (m *InternalRaftRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *InternalRaftRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.ID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.ID))
+	}
+	if m.V2 != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.V2.Size()))
+		n1, err := m.V2.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n1
+	}
+	if m.Range != nil {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.Range.Size()))
+		n2, err := m.Range.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n2
+	}
+	if m.Put != nil {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.Put.Size()))
+		n3, err := m.Put.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n3
+	}
+	if m.DeleteRange != nil {
+		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.DeleteRange.Size()))
+		n4, err := m.DeleteRange.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n4
+	}
+	if m.Txn != nil {
+		dAtA[i] = 0x32
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.Txn.Size()))
+		n5, err := m.Txn.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n5
+	}
+	if m.Compaction != nil {
+		dAtA[i] = 0x3a
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.Compaction.Size()))
+		n6, err := m.Compaction.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n6
+	}
+	if m.LeaseGrant != nil {
+		dAtA[i] = 0x42
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.LeaseGrant.Size()))
+		n7, err := m.LeaseGrant.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n7
+	}
+	if m.LeaseRevoke != nil {
+		dAtA[i] = 0x4a
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.LeaseRevoke.Size()))
+		n8, err := m.LeaseRevoke.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n8
+	}
+	if m.Alarm != nil {
+		dAtA[i] = 0x52
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.Alarm.Size()))
+		n9, err := m.Alarm.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n9
+	}
+	if m.Header != nil {
+		dAtA[i] = 0xa2
+		i++
+		dAtA[i] = 0x6
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.Header.Size()))
+		n10, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n10
+	}
+	if m.AuthEnable != nil {
+		dAtA[i] = 0xc2
+		i++
+		dAtA[i] = 0x3e
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthEnable.Size()))
+		n11, err := m.AuthEnable.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n11
+	}
+	if m.AuthDisable != nil {
+		dAtA[i] = 0x9a
+		i++
+		dAtA[i] = 0x3f
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthDisable.Size()))
+		n12, err := m.AuthDisable.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n12
+	}
+	if m.Authenticate != nil {
+		dAtA[i] = 0xa2
+		i++
+		dAtA[i] = 0x3f
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.Authenticate.Size()))
+		n13, err := m.Authenticate.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n13
+	}
+	if m.AuthUserAdd != nil {
+		dAtA[i] = 0xe2
+		i++
+		dAtA[i] = 0x44
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthUserAdd.Size()))
+		n14, err := m.AuthUserAdd.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n14
+	}
+	if m.AuthUserDelete != nil {
+		dAtA[i] = 0xea
+		i++
+		dAtA[i] = 0x44
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthUserDelete.Size()))
+		n15, err := m.AuthUserDelete.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n15
+	}
+	if m.AuthUserGet != nil {
+		dAtA[i] = 0xf2
+		i++
+		dAtA[i] = 0x44
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthUserGet.Size()))
+		n16, err := m.AuthUserGet.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n16
+	}
+	if m.AuthUserChangePassword != nil {
+		dAtA[i] = 0xfa
+		i++
+		dAtA[i] = 0x44
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthUserChangePassword.Size()))
+		n17, err := m.AuthUserChangePassword.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n17
+	}
+	if m.AuthUserGrantRole != nil {
+		dAtA[i] = 0x82
+		i++
+		dAtA[i] = 0x45
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthUserGrantRole.Size()))
+		n18, err := m.AuthUserGrantRole.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n18
+	}
+	if m.AuthUserRevokeRole != nil {
+		dAtA[i] = 0x8a
+		i++
+		dAtA[i] = 0x45
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthUserRevokeRole.Size()))
+		n19, err := m.AuthUserRevokeRole.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n19
+	}
+	if m.AuthUserList != nil {
+		dAtA[i] = 0x92
+		i++
+		dAtA[i] = 0x45
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthUserList.Size()))
+		n20, err := m.AuthUserList.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n20
+	}
+	if m.AuthRoleList != nil {
+		dAtA[i] = 0x9a
+		i++
+		dAtA[i] = 0x45
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthRoleList.Size()))
+		n21, err := m.AuthRoleList.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n21
+	}
+	if m.AuthRoleAdd != nil {
+		dAtA[i] = 0x82
+		i++
+		dAtA[i] = 0x4b
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthRoleAdd.Size()))
+		n22, err := m.AuthRoleAdd.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n22
+	}
+	if m.AuthRoleDelete != nil {
+		dAtA[i] = 0x8a
+		i++
+		dAtA[i] = 0x4b
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthRoleDelete.Size()))
+		n23, err := m.AuthRoleDelete.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n23
+	}
+	if m.AuthRoleGet != nil {
+		dAtA[i] = 0x92
+		i++
+		dAtA[i] = 0x4b
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthRoleGet.Size()))
+		n24, err := m.AuthRoleGet.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n24
+	}
+	if m.AuthRoleGrantPermission != nil {
+		dAtA[i] = 0x9a
+		i++
+		dAtA[i] = 0x4b
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthRoleGrantPermission.Size()))
+		n25, err := m.AuthRoleGrantPermission.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n25
+	}
+	if m.AuthRoleRevokePermission != nil {
+		dAtA[i] = 0xa2
+		i++
+		dAtA[i] = 0x4b
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(m.AuthRoleRevokePermission.Size()))
+		n26, err := m.AuthRoleRevokePermission.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n26
+	}
+	return i, nil
+}
+
+func (m *EmptyResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *EmptyResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	return i, nil
+}
+
+func (m *InternalAuthenticateRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *InternalAuthenticateRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	if len(m.Password) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(len(m.Password)))
+		i += copy(dAtA[i:], m.Password)
+	}
+	if len(m.SimpleToken) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintRaftInternal(dAtA, i, uint64(len(m.SimpleToken)))
+		i += copy(dAtA[i:], m.SimpleToken)
+	}
+	return i, nil
+}
+
+func encodeFixed64RaftInternal(dAtA []byte, offset int, v uint64) int {
+	dAtA[offset] = uint8(v)
+	dAtA[offset+1] = uint8(v >> 8)
+	dAtA[offset+2] = uint8(v >> 16)
+	dAtA[offset+3] = uint8(v >> 24)
+	dAtA[offset+4] = uint8(v >> 32)
+	dAtA[offset+5] = uint8(v >> 40)
+	dAtA[offset+6] = uint8(v >> 48)
+	dAtA[offset+7] = uint8(v >> 56)
+	return offset + 8
+}
+func encodeFixed32RaftInternal(dAtA []byte, offset int, v uint32) int {
+	dAtA[offset] = uint8(v)
+	dAtA[offset+1] = uint8(v >> 8)
+	dAtA[offset+2] = uint8(v >> 16)
+	dAtA[offset+3] = uint8(v >> 24)
+	return offset + 4
+}
+func encodeVarintRaftInternal(dAtA []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return offset + 1
+}
+func (m *RequestHeader) Size() (n int) {
+	var l int
+	_ = l
+	if m.ID != 0 {
+		n += 1 + sovRaftInternal(uint64(m.ID))
+	}
+	l = len(m.Username)
+	if l > 0 {
+		n += 1 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthRevision != 0 {
+		n += 1 + sovRaftInternal(uint64(m.AuthRevision))
+	}
+	return n
+}
+
+func (m *InternalRaftRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.ID != 0 {
+		n += 1 + sovRaftInternal(uint64(m.ID))
+	}
+	if m.V2 != nil {
+		l = m.V2.Size()
+		n += 1 + l + sovRaftInternal(uint64(l))
+	}
+	if m.Range != nil {
+		l = m.Range.Size()
+		n += 1 + l + sovRaftInternal(uint64(l))
+	}
+	if m.Put != nil {
+		l = m.Put.Size()
+		n += 1 + l + sovRaftInternal(uint64(l))
+	}
+	if m.DeleteRange != nil {
+		l = m.DeleteRange.Size()
+		n += 1 + l + sovRaftInternal(uint64(l))
+	}
+	if m.Txn != nil {
+		l = m.Txn.Size()
+		n += 1 + l + sovRaftInternal(uint64(l))
+	}
+	if m.Compaction != nil {
+		l = m.Compaction.Size()
+		n += 1 + l + sovRaftInternal(uint64(l))
+	}
+	if m.LeaseGrant != nil {
+		l = m.LeaseGrant.Size()
+		n += 1 + l + sovRaftInternal(uint64(l))
+	}
+	if m.LeaseRevoke != nil {
+		l = m.LeaseRevoke.Size()
+		n += 1 + l + sovRaftInternal(uint64(l))
+	}
+	if m.Alarm != nil {
+		l = m.Alarm.Size()
+		n += 1 + l + sovRaftInternal(uint64(l))
+	}
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthEnable != nil {
+		l = m.AuthEnable.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthDisable != nil {
+		l = m.AuthDisable.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.Authenticate != nil {
+		l = m.Authenticate.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthUserAdd != nil {
+		l = m.AuthUserAdd.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthUserDelete != nil {
+		l = m.AuthUserDelete.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthUserGet != nil {
+		l = m.AuthUserGet.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthUserChangePassword != nil {
+		l = m.AuthUserChangePassword.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthUserGrantRole != nil {
+		l = m.AuthUserGrantRole.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthUserRevokeRole != nil {
+		l = m.AuthUserRevokeRole.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthUserList != nil {
+		l = m.AuthUserList.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthRoleList != nil {
+		l = m.AuthRoleList.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthRoleAdd != nil {
+		l = m.AuthRoleAdd.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthRoleDelete != nil {
+		l = m.AuthRoleDelete.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthRoleGet != nil {
+		l = m.AuthRoleGet.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthRoleGrantPermission != nil {
+		l = m.AuthRoleGrantPermission.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	if m.AuthRoleRevokePermission != nil {
+		l = m.AuthRoleRevokePermission.Size()
+		n += 2 + l + sovRaftInternal(uint64(l))
+	}
+	return n
+}
+
+func (m *EmptyResponse) Size() (n int) {
+	var l int
+	_ = l
+	return n
+}
+
+func (m *InternalAuthenticateRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovRaftInternal(uint64(l))
+	}
+	l = len(m.Password)
+	if l > 0 {
+		n += 1 + l + sovRaftInternal(uint64(l))
+	}
+	l = len(m.SimpleToken)
+	if l > 0 {
+		n += 1 + l + sovRaftInternal(uint64(l))
+	}
+	return n
+}
+
+func sovRaftInternal(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozRaftInternal(x uint64) (n int) {
+	return sovRaftInternal(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *RequestHeader) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRaftInternal
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: RequestHeader: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: RequestHeader: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Username", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Username = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthRevision", wireType)
+			}
+			m.AuthRevision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.AuthRevision |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRaftInternal(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *InternalRaftRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRaftInternal
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: InternalRaftRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: InternalRaftRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field V2", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.V2 == nil {
+				m.V2 = &Request{}
+			}
+			if err := m.V2.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Range", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Range == nil {
+				m.Range = &RangeRequest{}
+			}
+			if err := m.Range.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Put", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Put == nil {
+				m.Put = &PutRequest{}
+			}
+			if err := m.Put.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DeleteRange", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.DeleteRange == nil {
+				m.DeleteRange = &DeleteRangeRequest{}
+			}
+			if err := m.DeleteRange.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Txn", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Txn == nil {
+				m.Txn = &TxnRequest{}
+			}
+			if err := m.Txn.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Compaction", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Compaction == nil {
+				m.Compaction = &CompactionRequest{}
+			}
+			if err := m.Compaction.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 8:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LeaseGrant", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.LeaseGrant == nil {
+				m.LeaseGrant = &LeaseGrantRequest{}
+			}
+			if err := m.LeaseGrant.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 9:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field LeaseRevoke", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.LeaseRevoke == nil {
+				m.LeaseRevoke = &LeaseRevokeRequest{}
+			}
+			if err := m.LeaseRevoke.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 10:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Alarm", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Alarm == nil {
+				m.Alarm = &AlarmRequest{}
+			}
+			if err := m.Alarm.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 100:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &RequestHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1000:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthEnable", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuthEnable == nil {
+				m.AuthEnable = &AuthEnableRequest{}
+			}
+			if err := m.AuthEnable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1011:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthDisable", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuthDisable == nil {
+				m.AuthDisable = &AuthDisableRequest{}
+			}
+			if err := m.AuthDisable.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1012:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Authenticate", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Authenticate == nil {
+				m.Authenticate = &InternalAuthenticateRequest{}
+			}
+			if err := m.Authenticate.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1100:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthUserAdd", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuthUserAdd == nil {
+				m.AuthUserAdd = &AuthUserAddRequest{}
+			}
+			if err := m.AuthUserAdd.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1101:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthUserDelete", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuthUserDelete == nil {
+				m.AuthUserDelete = &AuthUserDeleteRequest{}
+			}
+			if err := m.AuthUserDelete.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1102:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthUserGet", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuthUserGet == nil {
+				m.AuthUserGet = &AuthUserGetRequest{}
+			}
+			if err := m.AuthUserGet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1103:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthUserChangePassword", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuthUserChangePassword == nil {
+				m.AuthUserChangePassword = &AuthUserChangePasswordRequest{}
+			}
+			if err := m.AuthUserChangePassword.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1104:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthUserGrantRole", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuthUserGrantRole == nil {
+				m.AuthUserGrantRole = &AuthUserGrantRoleRequest{}
+			}
+			if err := m.AuthUserGrantRole.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1105:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthUserRevokeRole", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuthUserRevokeRole == nil {
+				m.AuthUserRevokeRole = &AuthUserRevokeRoleRequest{}
+			}
+			if err := m.AuthUserRevokeRole.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1106:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthUserList", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuthUserList == nil {
+				m.AuthUserList = &AuthUserListRequest{}
+			}
+			if err := m.AuthUserList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1107:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthRoleList", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuthRoleList == nil {
+				m.AuthRoleList = &AuthRoleListRequest{}
+			}
+			if err := m.AuthRoleList.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1200:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthRoleAdd", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuthRoleAdd == nil {
+				m.AuthRoleAdd = &AuthRoleAddRequest{}
+			}
+			if err := m.AuthRoleAdd.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1201:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthRoleDelete", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuthRoleDelete == nil {
+				m.AuthRoleDelete = &AuthRoleDeleteRequest{}
+			}
+			if err := m.AuthRoleDelete.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1202:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthRoleGet", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuthRoleGet == nil {
+				m.AuthRoleGet = &AuthRoleGetRequest{}
+			}
+			if err := m.AuthRoleGet.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1203:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthRoleGrantPermission", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuthRoleGrantPermission == nil {
+				m.AuthRoleGrantPermission = &AuthRoleGrantPermissionRequest{}
+			}
+			if err := m.AuthRoleGrantPermission.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 1204:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field AuthRoleRevokePermission", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.AuthRoleRevokePermission == nil {
+				m.AuthRoleRevokePermission = &AuthRoleRevokePermissionRequest{}
+			}
+			if err := m.AuthRoleRevokePermission.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRaftInternal(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *EmptyResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRaftInternal
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: EmptyResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: EmptyResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRaftInternal(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *InternalAuthenticateRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRaftInternal
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: InternalAuthenticateRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: InternalAuthenticateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Password = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SimpleToken", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.SimpleToken = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRaftInternal(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRaftInternal
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipRaftInternal(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowRaftInternal
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowRaftInternal
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			iNdEx += length
+			if length < 0 {
+				return 0, ErrInvalidLengthRaftInternal
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowRaftInternal
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipRaftInternal(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthRaftInternal = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowRaftInternal   = fmt.Errorf("proto: integer overflow")
+)
+
+func init() { proto.RegisterFile("raft_internal.proto", fileDescriptorRaftInternal) }
+
+var fileDescriptorRaftInternal = []byte{
+	// 837 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x7c, 0x96, 0xdd, 0x52, 0xd3, 0x40,
+	0x14, 0xc7, 0x69, 0xf9, 0xec, 0xb6, 0x54, 0x5c, 0x40, 0xd7, 0x32, 0x53, 0xa1, 0x8c, 0x8a, 0x5f,
+	0xe8, 0x94, 0x07, 0xd0, 0x4a, 0x19, 0x60, 0x86, 0x61, 0x98, 0x0c, 0xce, 0x38, 0xe3, 0x45, 0x5c,
+	0x9a, 0x43, 0x1b, 0x49, 0x93, 0xb8, 0xd9, 0x56, 0x7c, 0x13, 0x1f, 0xc3, 0xaf, 0x87, 0xe0, 0xc2,
+	0x0f, 0xd4, 0x17, 0x50, 0xbc, 0xf1, 0xca, 0x1b, 0x7d, 0x00, 0x67, 0x3f, 0x92, 0x34, 0x6d, 0xca,
+	0x5d, 0x72, 0xce, 0xff, 0xfc, 0xce, 0xd9, 0xec, 0x7f, 0xbb, 0x45, 0xb3, 0x8c, 0x1e, 0x72, 0xd3,
+	0x76, 0x39, 0x30, 0x97, 0x3a, 0xab, 0x3e, 0xf3, 0xb8, 0x87, 0x0b, 0xc0, 0x1b, 0x56, 0x00, 0xac,
+	0x0b, 0xcc, 0x3f, 0x28, 0xcd, 0x35, 0xbd, 0xa6, 0x27, 0x13, 0xf7, 0xc4, 0x93, 0xd2, 0x94, 0x66,
+	0x62, 0x8d, 0x8e, 0xe4, 0x98, 0xdf, 0x50, 0x8f, 0x95, 0x67, 0x68, 0xda, 0x80, 0x17, 0x1d, 0x08,
+	0xf8, 0x16, 0x50, 0x0b, 0x18, 0x2e, 0xa2, 0xec, 0x76, 0x9d, 0x64, 0x16, 0x33, 0x2b, 0x63, 0x46,
+	0x76, 0xbb, 0x8e, 0x4b, 0x68, 0xaa, 0x13, 0x88, 0x96, 0x6d, 0x20, 0xd9, 0xc5, 0xcc, 0x4a, 0xce,
+	0x88, 0xde, 0xf1, 0x32, 0x9a, 0xa6, 0x1d, 0xde, 0x32, 0x19, 0x74, 0xed, 0xc0, 0xf6, 0x5c, 0x32,
+	0x2a, 0xcb, 0x0a, 0x22, 0x68, 0xe8, 0x58, 0xe5, 0x4f, 0x11, 0xcd, 0x6e, 0xeb, 0xa9, 0x0d, 0x7a,
+	0xc8, 0x75, 0xbb, 0x81, 0x46, 0xd7, 0x50, 0xb6, 0x5b, 0x95, 0x2d, 0xf2, 0xd5, 0xf9, 0xd5, 0xde,
+	0x75, 0xad, 0xea, 0x12, 0x23, 0xdb, 0xad, 0xe2, 0xfb, 0x68, 0x9c, 0x51, 0xb7, 0x09, 0xb2, 0x57,
+	0xbe, 0x5a, 0xea, 0x53, 0x8a, 0x54, 0x28, 0x57, 0x42, 0x7c, 0x0b, 0x8d, 0xfa, 0x1d, 0x4e, 0xc6,
+	0xa4, 0x9e, 0x24, 0xf5, 0x7b, 0x9d, 0x70, 0x1e, 0x43, 0x88, 0xf0, 0x3a, 0x2a, 0x58, 0xe0, 0x00,
+	0x07, 0x53, 0x35, 0x19, 0x97, 0x45, 0x8b, 0xc9, 0xa2, 0xba, 0x54, 0x24, 0x5a, 0xe5, 0xad, 0x38,
+	0x26, 0x1a, 0xf2, 0x63, 0x97, 0x4c, 0xa4, 0x35, 0xdc, 0x3f, 0x76, 0xa3, 0x86, 0xfc, 0xd8, 0xc5,
+	0x0f, 0x10, 0x6a, 0x78, 0x6d, 0x9f, 0x36, 0xb8, 0xf8, 0x7e, 0x93, 0xb2, 0xe4, 0x6a, 0xb2, 0x64,
+	0x3d, 0xca, 0x87, 0x95, 0x3d, 0x25, 0xf8, 0x21, 0xca, 0x3b, 0x40, 0x03, 0x30, 0x9b, 0x8c, 0xba,
+	0x9c, 0x4c, 0xa5, 0x11, 0x76, 0x84, 0x60, 0x53, 0xe4, 0x23, 0x82, 0x13, 0x85, 0xc4, 0x9a, 0x15,
+	0x81, 0x41, 0xd7, 0x3b, 0x02, 0x92, 0x4b, 0x5b, 0xb3, 0x44, 0x18, 0x52, 0x10, 0xad, 0xd9, 0x89,
+	0x63, 0x62, 0x5b, 0xa8, 0x43, 0x59, 0x9b, 0xa0, 0xb4, 0x6d, 0xa9, 0x89, 0x54, 0xb4, 0x2d, 0x52,
+	0x88, 0xd7, 0xd0, 0x44, 0x4b, 0x5a, 0x8e, 0x58, 0xb2, 0x64, 0x21, 0x75, 0xcf, 0x95, 0x2b, 0x0d,
+	0x2d, 0xc5, 0x35, 0x94, 0x97, 0x8e, 0x03, 0x97, 0x1e, 0x38, 0x40, 0x7e, 0xa7, 0x7e, 0xb0, 0x5a,
+	0x87, 0xb7, 0x36, 0xa4, 0x20, 0x5a, 0x2e, 0x8d, 0x42, 0xb8, 0x8e, 0xa4, 0x3f, 0x4d, 0xcb, 0x0e,
+	0x24, 0xe3, 0xef, 0x64, 0xda, 0x7a, 0x05, 0xa3, 0xae, 0x14, 0xd1, 0x7a, 0x69, 0x1c, 0xc3, 0xbb,
+	0x8a, 0x02, 0x2e, 0xb7, 0x1b, 0x94, 0x03, 0xf9, 0xa7, 0x28, 0x37, 0x93, 0x94, 0xd0, 0xf7, 0xb5,
+	0x1e, 0x69, 0x88, 0x4b, 0xd4, 0xe3, 0x0d, 0x7d, 0x94, 0xc4, 0xd9, 0x32, 0xa9, 0x65, 0x91, 0x8f,
+	0x53, 0xc3, 0xc6, 0x7a, 0x1c, 0x00, 0xab, 0x59, 0x56, 0x62, 0x2c, 0x1d, 0xc3, 0xbb, 0x68, 0x26,
+	0xc6, 0x28, 0x4f, 0x92, 0x4f, 0x8a, 0xb4, 0x9c, 0x4e, 0xd2, 0x66, 0xd6, 0xb0, 0x22, 0x4d, 0x84,
+	0x93, 0x63, 0x35, 0x81, 0x93, 0xcf, 0xe7, 0x8e, 0xb5, 0x09, 0x7c, 0x60, 0xac, 0x4d, 0xe0, 0xb8,
+	0x89, 0xae, 0xc4, 0x98, 0x46, 0x4b, 0x9c, 0x12, 0xd3, 0xa7, 0x41, 0xf0, 0xd2, 0x63, 0x16, 0xf9,
+	0xa2, 0x90, 0xb7, 0xd3, 0x91, 0xeb, 0x52, 0xbd, 0xa7, 0xc5, 0x21, 0xfd, 0x12, 0x4d, 0x4d, 0xe3,
+	0x27, 0x68, 0xae, 0x67, 0x5e, 0x61, 0x6f, 0x93, 0x79, 0x0e, 0x90, 0x53, 0xd5, 0xe3, 0xfa, 0x90,
+	0xb1, 0xe5, 0xd1, 0xf0, 0xe2, 0xad, 0xbe, 0x48, 0xfb, 0x33, 0xf8, 0x29, 0x9a, 0x8f, 0xc9, 0xea,
+	0xa4, 0x28, 0xf4, 0x57, 0x85, 0xbe, 0x91, 0x8e, 0xd6, 0x47, 0xa6, 0x87, 0x8d, 0xe9, 0x40, 0x0a,
+	0x6f, 0xa1, 0x62, 0x0c, 0x77, 0xec, 0x80, 0x93, 0x6f, 0x8a, 0xba, 0x94, 0x4e, 0xdd, 0xb1, 0x03,
+	0x9e, 0xf0, 0x51, 0x18, 0x8c, 0x48, 0x62, 0x34, 0x45, 0xfa, 0x3e, 0x94, 0x24, 0x5a, 0x0f, 0x90,
+	0xc2, 0x60, 0xb4, 0xf5, 0x92, 0x24, 0x1c, 0xf9, 0x26, 0x37, 0x6c, 0xeb, 0x45, 0x4d, 0xbf, 0x23,
+	0x75, 0x2c, 0x72, 0xa4, 0xc4, 0x68, 0x47, 0xbe, 0xcd, 0x0d, 0x73, 0xa4, 0xa8, 0x4a, 0x71, 0x64,
+	0x1c, 0x4e, 0x8e, 0x25, 0x1c, 0xf9, 0xee, 0xdc, 0xb1, 0xfa, 0x1d, 0xa9, 0x63, 0xf8, 0x39, 0x2a,
+	0xf5, 0x60, 0xa4, 0x51, 0x7c, 0x60, 0x6d, 0x3b, 0x90, 0xf7, 0xd8, 0x7b, 0xc5, 0xbc, 0x33, 0x84,
+	0x29, 0xe4, 0x7b, 0x91, 0x3a, 0xe4, 0x5f, 0xa6, 0xe9, 0x79, 0xdc, 0x46, 0x0b, 0x71, 0x2f, 0x6d,
+	0x9d, 0x9e, 0x66, 0x1f, 0x54, 0xb3, 0xbb, 0xe9, 0xcd, 0x94, 0x4b, 0x06, 0xbb, 0x11, 0x3a, 0x44,
+	0x50, 0xb9, 0x80, 0xa6, 0x37, 0xda, 0x3e, 0x7f, 0x65, 0x40, 0xe0, 0x7b, 0x6e, 0x00, 0x15, 0x1f,
+	0x2d, 0x9c, 0xf3, 0x43, 0x84, 0x31, 0x1a, 0x93, 0xb7, 0x7b, 0x46, 0xde, 0xee, 0xf2, 0x59, 0xdc,
+	0xfa, 0xd1, 0xf9, 0xd4, 0xb7, 0x7e, 0xf8, 0x8e, 0x97, 0x50, 0x21, 0xb0, 0xdb, 0xbe, 0x03, 0x26,
+	0xf7, 0x8e, 0x40, 0x5d, 0xfa, 0x39, 0x23, 0xaf, 0x62, 0xfb, 0x22, 0xf4, 0x68, 0xee, 0xe4, 0x67,
+	0x79, 0xe4, 0xe4, 0xac, 0x9c, 0x39, 0x3d, 0x2b, 0x67, 0x7e, 0x9c, 0x95, 0x33, 0xaf, 0x7f, 0x95,
+	0x47, 0x0e, 0x26, 0xe4, 0x5f, 0x8e, 0xb5, 0xff, 0x01, 0x00, 0x00, 0xff, 0xff, 0xff, 0xc9, 0xfc,
+	0x0e, 0xca, 0x08, 0x00, 0x00,
+}
diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal.proto b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal.proto
new file mode 100644
index 000000000..25d45d3c4
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/raft_internal.proto
@@ -0,0 +1,74 @@
+syntax = "proto3";
+package etcdserverpb;
+
+import "gogoproto/gogo.proto";
+import "etcdserver.proto";
+import "rpc.proto";
+
+option (gogoproto.marshaler_all) = true;
+option (gogoproto.sizer_all) = true;
+option (gogoproto.unmarshaler_all) = true;
+option (gogoproto.goproto_getters_all) = false;
+
+message RequestHeader {
+  uint64 ID = 1;
+  // username is a username that is associated with an auth token of gRPC connection
+  string username = 2;
+  // auth_revision is a revision number of auth.authStore. It is not related to mvcc
+  uint64 auth_revision = 3;
+}
+
+// An InternalRaftRequest is the union of all requests which can be
+// sent via raft.
+message InternalRaftRequest {
+  RequestHeader header = 100;
+  uint64 ID = 1;
+
+  Request v2 = 2;
+
+  RangeRequest range = 3;
+  PutRequest put = 4;
+  DeleteRangeRequest delete_range = 5;
+  TxnRequest txn = 6;
+  CompactionRequest compaction = 7;
+
+  LeaseGrantRequest lease_grant = 8;
+  LeaseRevokeRequest lease_revoke = 9;
+
+  AlarmRequest alarm = 10;
+
+  AuthEnableRequest auth_enable = 1000;
+  AuthDisableRequest auth_disable = 1011;
+
+  InternalAuthenticateRequest authenticate = 1012;
+
+  AuthUserAddRequest auth_user_add = 1100;
+  AuthUserDeleteRequest auth_user_delete = 1101;
+  AuthUserGetRequest auth_user_get = 1102;
+  AuthUserChangePasswordRequest auth_user_change_password = 1103;
+  AuthUserGrantRoleRequest auth_user_grant_role = 1104;
+  AuthUserRevokeRoleRequest auth_user_revoke_role = 1105;
+  AuthUserListRequest auth_user_list = 1106;
+  AuthRoleListRequest auth_role_list = 1107;
+
+  AuthRoleAddRequest auth_role_add = 1200;
+  AuthRoleDeleteRequest auth_role_delete = 1201;
+  AuthRoleGetRequest auth_role_get = 1202;
+  AuthRoleGrantPermissionRequest auth_role_grant_permission = 1203;
+  AuthRoleRevokePermissionRequest auth_role_revoke_permission = 1204;
+}
+
+message EmptyResponse {
+}
+
+// What is the difference between AuthenticateRequest (defined in rpc.proto) and InternalAuthenticateRequest?
+// InternalAuthenticateRequest has a member that is filled by etcdserver and shouldn't be user-facing.
+// For avoiding misusage the field, we have an internal version of AuthenticateRequest.
+message InternalAuthenticateRequest {
+  string name = 1;
+  string password = 2;
+
+  // simple_token is generated in API layer (etcdserver/v3_server.go)
+  string simple_token = 3;
+}
+
diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.pb.go b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.pb.go
new file mode 100644
index 000000000..97e0c4c49
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.pb.go
@@ -0,0 +1,18682 @@
+// Code generated by protoc-gen-gogo.
+// source: rpc.proto
+// DO NOT EDIT!
+
+package etcdserverpb
+
+import (
+	"fmt"
+
+	proto "github.com/golang/protobuf/proto"
+
+	math "math"
+
+	mvccpb "github.com/coreos/etcd/mvcc/mvccpb"
+
+	authpb "github.com/coreos/etcd/auth/authpb"
+
+	context "golang.org/x/net/context"
+
+	grpc "google.golang.org/grpc"
+
+	io "io"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+type AlarmType int32
+
+const (
+	AlarmType_NONE    AlarmType = 0
+	AlarmType_NOSPACE AlarmType = 1
+	AlarmType_CORRUPT AlarmType = 2
+)
+
+var AlarmType_name = map[int32]string{
+	0: "NONE",
+	1: "NOSPACE",
+	2: "CORRUPT",
+}
+var AlarmType_value = map[string]int32{
+	"NONE":    0,
+	"NOSPACE": 1,
+	"CORRUPT": 2,
+}
+
+func (x AlarmType) String() string {
+	return proto.EnumName(AlarmType_name, int32(x))
+}
+func (AlarmType) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{0} }
+
+type RangeRequest_SortOrder int32
+
+const (
+	RangeRequest_NONE    RangeRequest_SortOrder = 0
+	RangeRequest_ASCEND  RangeRequest_SortOrder = 1
+	RangeRequest_DESCEND RangeRequest_SortOrder = 2
+)
+
+var RangeRequest_SortOrder_name = map[int32]string{
+	0: "NONE",
+	1: "ASCEND",
+	2: "DESCEND",
+}
+var RangeRequest_SortOrder_value = map[string]int32{
+	"NONE":    0,
+	"ASCEND":  1,
+	"DESCEND": 2,
+}
+
+func (x RangeRequest_SortOrder) String() string {
+	return proto.EnumName(RangeRequest_SortOrder_name, int32(x))
+}
+func (RangeRequest_SortOrder) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{1, 0} }
+
+type RangeRequest_SortTarget int32
+
+const (
+	RangeRequest_KEY     RangeRequest_SortTarget = 0
+	RangeRequest_VERSION RangeRequest_SortTarget = 1
+	RangeRequest_CREATE  RangeRequest_SortTarget = 2
+	RangeRequest_MOD     RangeRequest_SortTarget = 3
+	RangeRequest_VALUE   RangeRequest_SortTarget = 4
+)
+
+var RangeRequest_SortTarget_name = map[int32]string{
+	0: "KEY",
+	1: "VERSION",
+	2: "CREATE",
+	3: "MOD",
+	4: "VALUE",
+}
+var RangeRequest_SortTarget_value = map[string]int32{
+	"KEY":     0,
+	"VERSION": 1,
+	"CREATE":  2,
+	"MOD":     3,
+	"VALUE":   4,
+}
+
+func (x RangeRequest_SortTarget) String() string {
+	return proto.EnumName(RangeRequest_SortTarget_name, int32(x))
+}
+func (RangeRequest_SortTarget) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{1, 1} }
+
+type Compare_CompareResult int32
+
+const (
+	Compare_EQUAL     Compare_CompareResult = 0
+	Compare_GREATER   Compare_CompareResult = 1
+	Compare_LESS      Compare_CompareResult = 2
+	Compare_NOT_EQUAL Compare_CompareResult = 3
+)
+
+var Compare_CompareResult_name = map[int32]string{
+	0: "EQUAL",
+	1: "GREATER",
+	2: "LESS",
+	3: "NOT_EQUAL",
+}
+var Compare_CompareResult_value = map[string]int32{
+	"EQUAL":     0,
+	"GREATER":   1,
+	"LESS":      2,
+	"NOT_EQUAL": 3,
+}
+
+func (x Compare_CompareResult) String() string {
+	return proto.EnumName(Compare_CompareResult_name, int32(x))
+}
+func (Compare_CompareResult) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{9, 0} }
+
+type Compare_CompareTarget int32
+
+const (
+	Compare_VERSION Compare_CompareTarget = 0
+	Compare_CREATE  Compare_CompareTarget = 1
+	Compare_MOD     Compare_CompareTarget = 2
+	Compare_VALUE   Compare_CompareTarget = 3
+	Compare_LEASE   Compare_CompareTarget = 4
+)
+
+var Compare_CompareTarget_name = map[int32]string{
+	0: "VERSION",
+	1: "CREATE",
+	2: "MOD",
+	3: "VALUE",
+	4: "LEASE",
+}
+var Compare_CompareTarget_value = map[string]int32{
+	"VERSION": 0,
+	"CREATE":  1,
+	"MOD":     2,
+	"VALUE":   3,
+	"LEASE":   4,
+}
+
+func (x Compare_CompareTarget) String() string {
+	return proto.EnumName(Compare_CompareTarget_name, int32(x))
+}
+func (Compare_CompareTarget) EnumDescriptor() ([]byte, []int) { return fileDescriptorRpc, []int{9, 1} }
+
+type WatchCreateRequest_FilterType int32
+
+const (
+	// filter out put event.
+	WatchCreateRequest_NOPUT WatchCreateRequest_FilterType = 0
+	// filter out delete event.
+	WatchCreateRequest_NODELETE WatchCreateRequest_FilterType = 1
+)
+
+var WatchCreateRequest_FilterType_name = map[int32]string{
+	0: "NOPUT",
+	1: "NODELETE",
+}
+var WatchCreateRequest_FilterType_value = map[string]int32{
+	"NOPUT":    0,
+	"NODELETE": 1,
+}
+
+func (x WatchCreateRequest_FilterType) String() string {
+	return proto.EnumName(WatchCreateRequest_FilterType_name, int32(x))
+}
+func (WatchCreateRequest_FilterType) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptorRpc, []int{21, 0}
+}
+
+type AlarmRequest_AlarmAction int32
+
+const (
+	AlarmRequest_GET        AlarmRequest_AlarmAction = 0
+	AlarmRequest_ACTIVATE   AlarmRequest_AlarmAction = 1
+	AlarmRequest_DEACTIVATE AlarmRequest_AlarmAction = 2
+)
+
+var AlarmRequest_AlarmAction_name = map[int32]string{
+	0: "GET",
+	1: "ACTIVATE",
+	2: "DEACTIVATE",
+}
+var AlarmRequest_AlarmAction_value = map[string]int32{
+	"GET":        0,
+	"ACTIVATE":   1,
+	"DEACTIVATE": 2,
+}
+
+func (x AlarmRequest_AlarmAction) String() string {
+	return proto.EnumName(AlarmRequest_AlarmAction_name, int32(x))
+}
+func (AlarmRequest_AlarmAction) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptorRpc, []int{48, 0}
+}
+
+type ResponseHeader struct {
+	// cluster_id is the ID of the cluster which sent the response.
+	ClusterId uint64 `protobuf:"varint,1,opt,name=cluster_id,json=clusterId,proto3" json:"cluster_id,omitempty"`
+	// member_id is the ID of the member which sent the response.
+	MemberId uint64 `protobuf:"varint,2,opt,name=member_id,json=memberId,proto3" json:"member_id,omitempty"`
+	// revision is the key-value store revision when the request was applied.
+	Revision int64 `protobuf:"varint,3,opt,name=revision,proto3" json:"revision,omitempty"`
+	// raft_term is the raft term when the request was applied.
+	RaftTerm uint64 `protobuf:"varint,4,opt,name=raft_term,json=raftTerm,proto3" json:"raft_term,omitempty"`
+}
+
+func (m *ResponseHeader) Reset()                    { *m = ResponseHeader{} }
+func (m *ResponseHeader) String() string            { return proto.CompactTextString(m) }
+func (*ResponseHeader) ProtoMessage()               {}
+func (*ResponseHeader) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{0} }
+
+func (m *ResponseHeader) GetClusterId() uint64 {
+	if m != nil {
+		return m.ClusterId
+	}
+	return 0
+}
+
+func (m *ResponseHeader) GetMemberId() uint64 {
+	if m != nil {
+		return m.MemberId
+	}
+	return 0
+}
+
+func (m *ResponseHeader) GetRevision() int64 {
+	if m != nil {
+		return m.Revision
+	}
+	return 0
+}
+
+func (m *ResponseHeader) GetRaftTerm() uint64 {
+	if m != nil {
+		return m.RaftTerm
+	}
+	return 0
+}
+
+type RangeRequest struct {
+	// key is the first key for the range. If range_end is not given, the request only looks up key.
+	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	// range_end is the upper bound on the requested range [key, range_end).
+	// If range_end is '\0', the range is all keys >= key.
+	// If range_end is key plus one (e.g., "aa"+1 == "ab", "a\xff"+1 == "b"),
+	// then the range request gets all keys prefixed with key.
+	// If both key and range_end are '\0', then the range request returns all keys.
+	RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
+	// limit is a limit on the number of keys returned for the request. When limit is set to 0,
+	// it is treated as no limit.
+	Limit int64 `protobuf:"varint,3,opt,name=limit,proto3" json:"limit,omitempty"`
+	// revision is the point-in-time of the key-value store to use for the range.
+	// If revision is less or equal to zero, the range is over the newest key-value store.
+	// If the revision has been compacted, ErrCompacted is returned as a response.
+	Revision int64 `protobuf:"varint,4,opt,name=revision,proto3" json:"revision,omitempty"`
+	// sort_order is the order for returned sorted results.
+	SortOrder RangeRequest_SortOrder `protobuf:"varint,5,opt,name=sort_order,json=sortOrder,proto3,enum=etcdserverpb.RangeRequest_SortOrder" json:"sort_order,omitempty"`
+	// sort_target is the key-value field to use for sorting.
+	SortTarget RangeRequest_SortTarget `protobuf:"varint,6,opt,name=sort_target,json=sortTarget,proto3,enum=etcdserverpb.RangeRequest_SortTarget" json:"sort_target,omitempty"`
+	// serializable sets the range request to use serializable member-local reads.
+	// Range requests are linearizable by default; linearizable requests have higher
+	// latency and lower throughput than serializable requests but reflect the current
+	// consensus of the cluster. For better performance, in exchange for possible stale reads,
+	// a serializable range request is served locally without needing to reach consensus
+	// with other nodes in the cluster.
+	Serializable bool `protobuf:"varint,7,opt,name=serializable,proto3" json:"serializable,omitempty"`
+	// keys_only when set returns only the keys and not the values.
+	KeysOnly bool `protobuf:"varint,8,opt,name=keys_only,json=keysOnly,proto3" json:"keys_only,omitempty"`
+	// count_only when set returns only the count of the keys in the range.
+	CountOnly bool `protobuf:"varint,9,opt,name=count_only,json=countOnly,proto3" json:"count_only,omitempty"`
+	// min_mod_revision is the lower bound for returned key mod revisions; all keys with
+	// lesser mod revisions will be filtered away.
+	MinModRevision int64 `protobuf:"varint,10,opt,name=min_mod_revision,json=minModRevision,proto3" json:"min_mod_revision,omitempty"`
+	// max_mod_revision is the upper bound for returned key mod revisions; all keys with
+	// greater mod revisions will be filtered away.
+	MaxModRevision int64 `protobuf:"varint,11,opt,name=max_mod_revision,json=maxModRevision,proto3" json:"max_mod_revision,omitempty"`
+	// min_create_revision is the lower bound for returned key create revisions; all keys with
+	// lesser create trevisions will be filtered away.
+	MinCreateRevision int64 `protobuf:"varint,12,opt,name=min_create_revision,json=minCreateRevision,proto3" json:"min_create_revision,omitempty"`
+	// max_create_revision is the upper bound for returned key create revisions; all keys with
+	// greater create revisions will be filtered away.
+	MaxCreateRevision int64 `protobuf:"varint,13,opt,name=max_create_revision,json=maxCreateRevision,proto3" json:"max_create_revision,omitempty"`
+}
+
+func (m *RangeRequest) Reset()                    { *m = RangeRequest{} }
+func (m *RangeRequest) String() string            { return proto.CompactTextString(m) }
+func (*RangeRequest) ProtoMessage()               {}
+func (*RangeRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{1} }
+
+func (m *RangeRequest) GetKey() []byte {
+	if m != nil {
+		return m.Key
+	}
+	return nil
+}
+
+func (m *RangeRequest) GetRangeEnd() []byte {
+	if m != nil {
+		return m.RangeEnd
+	}
+	return nil
+}
+
+func (m *RangeRequest) GetLimit() int64 {
+	if m != nil {
+		return m.Limit
+	}
+	return 0
+}
+
+func (m *RangeRequest) GetRevision() int64 {
+	if m != nil {
+		return m.Revision
+	}
+	return 0
+}
+
+func (m *RangeRequest) GetSortOrder() RangeRequest_SortOrder {
+	if m != nil {
+		return m.SortOrder
+	}
+	return RangeRequest_NONE
+}
+
+func (m *RangeRequest) GetSortTarget() RangeRequest_SortTarget {
+	if m != nil {
+		return m.SortTarget
+	}
+	return RangeRequest_KEY
+}
+
+func (m *RangeRequest) GetSerializable() bool {
+	if m != nil {
+		return m.Serializable
+	}
+	return false
+}
+
+func (m *RangeRequest) GetKeysOnly() bool {
+	if m != nil {
+		return m.KeysOnly
+	}
+	return false
+}
+
+func (m *RangeRequest) GetCountOnly() bool {
+	if m != nil {
+		return m.CountOnly
+	}
+	return false
+}
+
+func (m *RangeRequest) GetMinModRevision() int64 {
+	if m != nil {
+		return m.MinModRevision
+	}
+	return 0
+}
+
+func (m *RangeRequest) GetMaxModRevision() int64 {
+	if m != nil {
+		return m.MaxModRevision
+	}
+	return 0
+}
+
+func (m *RangeRequest) GetMinCreateRevision() int64 {
+	if m != nil {
+		return m.MinCreateRevision
+	}
+	return 0
+}
+
+func (m *RangeRequest) GetMaxCreateRevision() int64 {
+	if m != nil {
+		return m.MaxCreateRevision
+	}
+	return 0
+}
+
+type RangeResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// kvs is the list of key-value pairs matched by the range request.
+	// kvs is empty when count is requested.
+	Kvs []*mvccpb.KeyValue `protobuf:"bytes,2,rep,name=kvs" json:"kvs,omitempty"`
+	// more indicates if there are more keys to return in the requested range.
+	More bool `protobuf:"varint,3,opt,name=more,proto3" json:"more,omitempty"`
+	// count is set to the number of keys within the range when requested.
+	Count int64 `protobuf:"varint,4,opt,name=count,proto3" json:"count,omitempty"`
+}
+
+func (m *RangeResponse) Reset()                    { *m = RangeResponse{} }
+func (m *RangeResponse) String() string            { return proto.CompactTextString(m) }
+func (*RangeResponse) ProtoMessage()               {}
+func (*RangeResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{2} }
+
+func (m *RangeResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *RangeResponse) GetKvs() []*mvccpb.KeyValue {
+	if m != nil {
+		return m.Kvs
+	}
+	return nil
+}
+
+func (m *RangeResponse) GetMore() bool {
+	if m != nil {
+		return m.More
+	}
+	return false
+}
+
+func (m *RangeResponse) GetCount() int64 {
+	if m != nil {
+		return m.Count
+	}
+	return 0
+}
+
+type PutRequest struct {
+	// key is the key, in bytes, to put into the key-value store.
+	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	// value is the value, in bytes, to associate with the key in the key-value store.
+	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+	// lease is the lease ID to associate with the key in the key-value store. A lease
+	// value of 0 indicates no lease.
+	Lease int64 `protobuf:"varint,3,opt,name=lease,proto3" json:"lease,omitempty"`
+	// If prev_kv is set, etcd gets the previous key-value pair before changing it.
+	// The previous key-value pair will be returned in the put response.
+	PrevKv bool `protobuf:"varint,4,opt,name=prev_kv,json=prevKv,proto3" json:"prev_kv,omitempty"`
+	// If ignore_value is set, etcd updates the key using its current value.
+	// Returns an error if the key does not exist.
+	IgnoreValue bool `protobuf:"varint,5,opt,name=ignore_value,json=ignoreValue,proto3" json:"ignore_value,omitempty"`
+	// If ignore_lease is set, etcd updates the key using its current lease.
+	// Returns an error if the key does not exist.
+	IgnoreLease bool `protobuf:"varint,6,opt,name=ignore_lease,json=ignoreLease,proto3" json:"ignore_lease,omitempty"`
+}
+
+func (m *PutRequest) Reset()                    { *m = PutRequest{} }
+func (m *PutRequest) String() string            { return proto.CompactTextString(m) }
+func (*PutRequest) ProtoMessage()               {}
+func (*PutRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{3} }
+
+func (m *PutRequest) GetKey() []byte {
+	if m != nil {
+		return m.Key
+	}
+	return nil
+}
+
+func (m *PutRequest) GetValue() []byte {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+func (m *PutRequest) GetLease() int64 {
+	if m != nil {
+		return m.Lease
+	}
+	return 0
+}
+
+func (m *PutRequest) GetPrevKv() bool {
+	if m != nil {
+		return m.PrevKv
+	}
+	return false
+}
+
+func (m *PutRequest) GetIgnoreValue() bool {
+	if m != nil {
+		return m.IgnoreValue
+	}
+	return false
+}
+
+func (m *PutRequest) GetIgnoreLease() bool {
+	if m != nil {
+		return m.IgnoreLease
+	}
+	return false
+}
+
+type PutResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// if prev_kv is set in the request, the previous key-value pair will be returned.
+	PrevKv *mvccpb.KeyValue `protobuf:"bytes,2,opt,name=prev_kv,json=prevKv" json:"prev_kv,omitempty"`
+}
+
+func (m *PutResponse) Reset()                    { *m = PutResponse{} }
+func (m *PutResponse) String() string            { return proto.CompactTextString(m) }
+func (*PutResponse) ProtoMessage()               {}
+func (*PutResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{4} }
+
+func (m *PutResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *PutResponse) GetPrevKv() *mvccpb.KeyValue {
+	if m != nil {
+		return m.PrevKv
+	}
+	return nil
+}
+
+type DeleteRangeRequest struct {
+	// key is the first key to delete in the range.
+	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	// range_end is the key following the last key to delete for the range [key, range_end).
+	// If range_end is not given, the range is defined to contain only the key argument.
+	// If range_end is one bit larger than the given key, then the range is all the keys
+	// with the prefix (the given key).
+	// If range_end is '\0', the range is all keys greater than or equal to the key argument.
+	RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
+	// If prev_kv is set, etcd gets the previous key-value pairs before deleting it.
+	// The previous key-value pairs will be returned in the delete response.
+	PrevKv bool `protobuf:"varint,3,opt,name=prev_kv,json=prevKv,proto3" json:"prev_kv,omitempty"`
+}
+
+func (m *DeleteRangeRequest) Reset()                    { *m = DeleteRangeRequest{} }
+func (m *DeleteRangeRequest) String() string            { return proto.CompactTextString(m) }
+func (*DeleteRangeRequest) ProtoMessage()               {}
+func (*DeleteRangeRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{5} }
+
+func (m *DeleteRangeRequest) GetKey() []byte {
+	if m != nil {
+		return m.Key
+	}
+	return nil
+}
+
+func (m *DeleteRangeRequest) GetRangeEnd() []byte {
+	if m != nil {
+		return m.RangeEnd
+	}
+	return nil
+}
+
+func (m *DeleteRangeRequest) GetPrevKv() bool {
+	if m != nil {
+		return m.PrevKv
+	}
+	return false
+}
+
+type DeleteRangeResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// deleted is the number of keys deleted by the delete range request.
+	Deleted int64 `protobuf:"varint,2,opt,name=deleted,proto3" json:"deleted,omitempty"`
+	// if prev_kv is set in the request, the previous key-value pairs will be returned.
+	PrevKvs []*mvccpb.KeyValue `protobuf:"bytes,3,rep,name=prev_kvs,json=prevKvs" json:"prev_kvs,omitempty"`
+}
+
+func (m *DeleteRangeResponse) Reset()                    { *m = DeleteRangeResponse{} }
+func (m *DeleteRangeResponse) String() string            { return proto.CompactTextString(m) }
+func (*DeleteRangeResponse) ProtoMessage()               {}
+func (*DeleteRangeResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{6} }
+
+func (m *DeleteRangeResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *DeleteRangeResponse) GetDeleted() int64 {
+	if m != nil {
+		return m.Deleted
+	}
+	return 0
+}
+
+func (m *DeleteRangeResponse) GetPrevKvs() []*mvccpb.KeyValue {
+	if m != nil {
+		return m.PrevKvs
+	}
+	return nil
+}
+
+type RequestOp struct {
+	// request is a union of request types accepted by a transaction.
+	//
+	// Types that are valid to be assigned to Request:
+	//	*RequestOp_RequestRange
+	//	*RequestOp_RequestPut
+	//	*RequestOp_RequestDeleteRange
+	//	*RequestOp_RequestTxn
+	Request isRequestOp_Request `protobuf_oneof:"request"`
+}
+
+func (m *RequestOp) Reset()                    { *m = RequestOp{} }
+func (m *RequestOp) String() string            { return proto.CompactTextString(m) }
+func (*RequestOp) ProtoMessage()               {}
+func (*RequestOp) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{7} }
+
+type isRequestOp_Request interface {
+	isRequestOp_Request()
+	MarshalTo([]byte) (int, error)
+	Size() int
+}
+
+type RequestOp_RequestRange struct {
+	RequestRange *RangeRequest `protobuf:"bytes,1,opt,name=request_range,json=requestRange,oneof"`
+}
+type RequestOp_RequestPut struct {
+	RequestPut *PutRequest `protobuf:"bytes,2,opt,name=request_put,json=requestPut,oneof"`
+}
+type RequestOp_RequestDeleteRange struct {
+	RequestDeleteRange *DeleteRangeRequest `protobuf:"bytes,3,opt,name=request_delete_range,json=requestDeleteRange,oneof"`
+}
+type RequestOp_RequestTxn struct {
+	RequestTxn *TxnRequest `protobuf:"bytes,4,opt,name=request_txn,json=requestTxn,oneof"`
+}
+
+func (*RequestOp_RequestRange) isRequestOp_Request()       {}
+func (*RequestOp_RequestPut) isRequestOp_Request()         {}
+func (*RequestOp_RequestDeleteRange) isRequestOp_Request() {}
+func (*RequestOp_RequestTxn) isRequestOp_Request()         {}
+
+func (m *RequestOp) GetRequest() isRequestOp_Request {
+	if m != nil {
+		return m.Request
+	}
+	return nil
+}
+
+func (m *RequestOp) GetRequestRange() *RangeRequest {
+	if x, ok := m.GetRequest().(*RequestOp_RequestRange); ok {
+		return x.RequestRange
+	}
+	return nil
+}
+
+func (m *RequestOp) GetRequestPut() *PutRequest {
+	if x, ok := m.GetRequest().(*RequestOp_RequestPut); ok {
+		return x.RequestPut
+	}
+	return nil
+}
+
+func (m *RequestOp) GetRequestDeleteRange() *DeleteRangeRequest {
+	if x, ok := m.GetRequest().(*RequestOp_RequestDeleteRange); ok {
+		return x.RequestDeleteRange
+	}
+	return nil
+}
+
+func (m *RequestOp) GetRequestTxn() *TxnRequest {
+	if x, ok := m.GetRequest().(*RequestOp_RequestTxn); ok {
+		return x.RequestTxn
+	}
+	return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*RequestOp) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _RequestOp_OneofMarshaler, _RequestOp_OneofUnmarshaler, _RequestOp_OneofSizer, []interface{}{
+		(*RequestOp_RequestRange)(nil),
+		(*RequestOp_RequestPut)(nil),
+		(*RequestOp_RequestDeleteRange)(nil),
+		(*RequestOp_RequestTxn)(nil),
+	}
+}
+
+func _RequestOp_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*RequestOp)
+	// request
+	switch x := m.Request.(type) {
+	case *RequestOp_RequestRange:
+		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.RequestRange); err != nil {
+			return err
+		}
+	case *RequestOp_RequestPut:
+		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.RequestPut); err != nil {
+			return err
+		}
+	case *RequestOp_RequestDeleteRange:
+		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.RequestDeleteRange); err != nil {
+			return err
+		}
+	case *RequestOp_RequestTxn:
+		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.RequestTxn); err != nil {
+			return err
+		}
+	case nil:
+	default:
+		return fmt.Errorf("RequestOp.Request has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _RequestOp_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*RequestOp)
+	switch tag {
+	case 1: // request.request_range
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(RangeRequest)
+		err := b.DecodeMessage(msg)
+		m.Request = &RequestOp_RequestRange{msg}
+		return true, err
+	case 2: // request.request_put
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(PutRequest)
+		err := b.DecodeMessage(msg)
+		m.Request = &RequestOp_RequestPut{msg}
+		return true, err
+	case 3: // request.request_delete_range
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(DeleteRangeRequest)
+		err := b.DecodeMessage(msg)
+		m.Request = &RequestOp_RequestDeleteRange{msg}
+		return true, err
+	case 4: // request.request_txn
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(TxnRequest)
+		err := b.DecodeMessage(msg)
+		m.Request = &RequestOp_RequestTxn{msg}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _RequestOp_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*RequestOp)
+	// request
+	switch x := m.Request.(type) {
+	case *RequestOp_RequestRange:
+		s := proto.Size(x.RequestRange)
+		n += proto.SizeVarint(1<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *RequestOp_RequestPut:
+		s := proto.Size(x.RequestPut)
+		n += proto.SizeVarint(2<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *RequestOp_RequestDeleteRange:
+		s := proto.Size(x.RequestDeleteRange)
+		n += proto.SizeVarint(3<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *RequestOp_RequestTxn:
+		s := proto.Size(x.RequestTxn)
+		n += proto.SizeVarint(4<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+type ResponseOp struct {
+	// response is a union of response types returned by a transaction.
+	//
+	// Types that are valid to be assigned to Response:
+	//	*ResponseOp_ResponseRange
+	//	*ResponseOp_ResponsePut
+	//	*ResponseOp_ResponseDeleteRange
+	//	*ResponseOp_ResponseTxn
+	Response isResponseOp_Response `protobuf_oneof:"response"`
+}
+
+func (m *ResponseOp) Reset()                    { *m = ResponseOp{} }
+func (m *ResponseOp) String() string            { return proto.CompactTextString(m) }
+func (*ResponseOp) ProtoMessage()               {}
+func (*ResponseOp) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{8} }
+
+type isResponseOp_Response interface {
+	isResponseOp_Response()
+	MarshalTo([]byte) (int, error)
+	Size() int
+}
+
+type ResponseOp_ResponseRange struct {
+	ResponseRange *RangeResponse `protobuf:"bytes,1,opt,name=response_range,json=responseRange,oneof"`
+}
+type ResponseOp_ResponsePut struct {
+	ResponsePut *PutResponse `protobuf:"bytes,2,opt,name=response_put,json=responsePut,oneof"`
+}
+type ResponseOp_ResponseDeleteRange struct {
+	ResponseDeleteRange *DeleteRangeResponse `protobuf:"bytes,3,opt,name=response_delete_range,json=responseDeleteRange,oneof"`
+}
+type ResponseOp_ResponseTxn struct {
+	ResponseTxn *TxnResponse `protobuf:"bytes,4,opt,name=response_txn,json=responseTxn,oneof"`
+}
+
+func (*ResponseOp_ResponseRange) isResponseOp_Response()       {}
+func (*ResponseOp_ResponsePut) isResponseOp_Response()         {}
+func (*ResponseOp_ResponseDeleteRange) isResponseOp_Response() {}
+func (*ResponseOp_ResponseTxn) isResponseOp_Response()         {}
+
+func (m *ResponseOp) GetResponse() isResponseOp_Response {
+	if m != nil {
+		return m.Response
+	}
+	return nil
+}
+
+func (m *ResponseOp) GetResponseRange() *RangeResponse {
+	if x, ok := m.GetResponse().(*ResponseOp_ResponseRange); ok {
+		return x.ResponseRange
+	}
+	return nil
+}
+
+func (m *ResponseOp) GetResponsePut() *PutResponse {
+	if x, ok := m.GetResponse().(*ResponseOp_ResponsePut); ok {
+		return x.ResponsePut
+	}
+	return nil
+}
+
+func (m *ResponseOp) GetResponseDeleteRange() *DeleteRangeResponse {
+	if x, ok := m.GetResponse().(*ResponseOp_ResponseDeleteRange); ok {
+		return x.ResponseDeleteRange
+	}
+	return nil
+}
+
+func (m *ResponseOp) GetResponseTxn() *TxnResponse {
+	if x, ok := m.GetResponse().(*ResponseOp_ResponseTxn); ok {
+		return x.ResponseTxn
+	}
+	return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*ResponseOp) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _ResponseOp_OneofMarshaler, _ResponseOp_OneofUnmarshaler, _ResponseOp_OneofSizer, []interface{}{
+		(*ResponseOp_ResponseRange)(nil),
+		(*ResponseOp_ResponsePut)(nil),
+		(*ResponseOp_ResponseDeleteRange)(nil),
+		(*ResponseOp_ResponseTxn)(nil),
+	}
+}
+
+func _ResponseOp_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*ResponseOp)
+	// response
+	switch x := m.Response.(type) {
+	case *ResponseOp_ResponseRange:
+		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.ResponseRange); err != nil {
+			return err
+		}
+	case *ResponseOp_ResponsePut:
+		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.ResponsePut); err != nil {
+			return err
+		}
+	case *ResponseOp_ResponseDeleteRange:
+		_ = b.EncodeVarint(3<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.ResponseDeleteRange); err != nil {
+			return err
+		}
+	case *ResponseOp_ResponseTxn:
+		_ = b.EncodeVarint(4<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.ResponseTxn); err != nil {
+			return err
+		}
+	case nil:
+	default:
+		return fmt.Errorf("ResponseOp.Response has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _ResponseOp_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*ResponseOp)
+	switch tag {
+	case 1: // response.response_range
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(RangeResponse)
+		err := b.DecodeMessage(msg)
+		m.Response = &ResponseOp_ResponseRange{msg}
+		return true, err
+	case 2: // response.response_put
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(PutResponse)
+		err := b.DecodeMessage(msg)
+		m.Response = &ResponseOp_ResponsePut{msg}
+		return true, err
+	case 3: // response.response_delete_range
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(DeleteRangeResponse)
+		err := b.DecodeMessage(msg)
+		m.Response = &ResponseOp_ResponseDeleteRange{msg}
+		return true, err
+	case 4: // response.response_txn
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(TxnResponse)
+		err := b.DecodeMessage(msg)
+		m.Response = &ResponseOp_ResponseTxn{msg}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _ResponseOp_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*ResponseOp)
+	// response
+	switch x := m.Response.(type) {
+	case *ResponseOp_ResponseRange:
+		s := proto.Size(x.ResponseRange)
+		n += proto.SizeVarint(1<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *ResponseOp_ResponsePut:
+		s := proto.Size(x.ResponsePut)
+		n += proto.SizeVarint(2<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *ResponseOp_ResponseDeleteRange:
+		s := proto.Size(x.ResponseDeleteRange)
+		n += proto.SizeVarint(3<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *ResponseOp_ResponseTxn:
+		s := proto.Size(x.ResponseTxn)
+		n += proto.SizeVarint(4<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+type Compare struct {
+	// result is logical comparison operation for this comparison.
+	Result Compare_CompareResult `protobuf:"varint,1,opt,name=result,proto3,enum=etcdserverpb.Compare_CompareResult" json:"result,omitempty"`
+	// target is the key-value field to inspect for the comparison.
+	Target Compare_CompareTarget `protobuf:"varint,2,opt,name=target,proto3,enum=etcdserverpb.Compare_CompareTarget" json:"target,omitempty"`
+	// key is the subject key for the comparison operation.
+	Key []byte `protobuf:"bytes,3,opt,name=key,proto3" json:"key,omitempty"`
+	// Types that are valid to be assigned to TargetUnion:
+	//	*Compare_Version
+	//	*Compare_CreateRevision
+	//	*Compare_ModRevision
+	//	*Compare_Value
+	//	*Compare_Lease
+	TargetUnion isCompare_TargetUnion `protobuf_oneof:"target_union"`
+	// range_end compares the given target to all keys in the range [key, range_end).
+	// See RangeRequest for more details on key ranges.
+	RangeEnd []byte `protobuf:"bytes,64,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
+}
+
+func (m *Compare) Reset()                    { *m = Compare{} }
+func (m *Compare) String() string            { return proto.CompactTextString(m) }
+func (*Compare) ProtoMessage()               {}
+func (*Compare) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{9} }
+
+type isCompare_TargetUnion interface {
+	isCompare_TargetUnion()
+	MarshalTo([]byte) (int, error)
+	Size() int
+}
+
+type Compare_Version struct {
+	Version int64 `protobuf:"varint,4,opt,name=version,proto3,oneof"`
+}
+type Compare_CreateRevision struct {
+	CreateRevision int64 `protobuf:"varint,5,opt,name=create_revision,json=createRevision,proto3,oneof"`
+}
+type Compare_ModRevision struct {
+	ModRevision int64 `protobuf:"varint,6,opt,name=mod_revision,json=modRevision,proto3,oneof"`
+}
+type Compare_Value struct {
+	Value []byte `protobuf:"bytes,7,opt,name=value,proto3,oneof"`
+}
+type Compare_Lease struct {
+	Lease int64 `protobuf:"varint,8,opt,name=lease,proto3,oneof"`
+}
+
+func (*Compare_Version) isCompare_TargetUnion()        {}
+func (*Compare_CreateRevision) isCompare_TargetUnion() {}
+func (*Compare_ModRevision) isCompare_TargetUnion()    {}
+func (*Compare_Value) isCompare_TargetUnion()          {}
+func (*Compare_Lease) isCompare_TargetUnion()          {}
+
+func (m *Compare) GetTargetUnion() isCompare_TargetUnion {
+	if m != nil {
+		return m.TargetUnion
+	}
+	return nil
+}
+
+func (m *Compare) GetResult() Compare_CompareResult {
+	if m != nil {
+		return m.Result
+	}
+	return Compare_EQUAL
+}
+
+func (m *Compare) GetTarget() Compare_CompareTarget {
+	if m != nil {
+		return m.Target
+	}
+	return Compare_VERSION
+}
+
+func (m *Compare) GetKey() []byte {
+	if m != nil {
+		return m.Key
+	}
+	return nil
+}
+
+func (m *Compare) GetVersion() int64 {
+	if x, ok := m.GetTargetUnion().(*Compare_Version); ok {
+		return x.Version
+	}
+	return 0
+}
+
+func (m *Compare) GetCreateRevision() int64 {
+	if x, ok := m.GetTargetUnion().(*Compare_CreateRevision); ok {
+		return x.CreateRevision
+	}
+	return 0
+}
+
+func (m *Compare) GetModRevision() int64 {
+	if x, ok := m.GetTargetUnion().(*Compare_ModRevision); ok {
+		return x.ModRevision
+	}
+	return 0
+}
+
+func (m *Compare) GetValue() []byte {
+	if x, ok := m.GetTargetUnion().(*Compare_Value); ok {
+		return x.Value
+	}
+	return nil
+}
+
+func (m *Compare) GetLease() int64 {
+	if x, ok := m.GetTargetUnion().(*Compare_Lease); ok {
+		return x.Lease
+	}
+	return 0
+}
+
+func (m *Compare) GetRangeEnd() []byte {
+	if m != nil {
+		return m.RangeEnd
+	}
+	return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*Compare) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _Compare_OneofMarshaler, _Compare_OneofUnmarshaler, _Compare_OneofSizer, []interface{}{
+		(*Compare_Version)(nil),
+		(*Compare_CreateRevision)(nil),
+		(*Compare_ModRevision)(nil),
+		(*Compare_Value)(nil),
+		(*Compare_Lease)(nil),
+	}
+}
+
+func _Compare_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*Compare)
+	// target_union
+	switch x := m.TargetUnion.(type) {
+	case *Compare_Version:
+		_ = b.EncodeVarint(4<<3 | proto.WireVarint)
+		_ = b.EncodeVarint(uint64(x.Version))
+	case *Compare_CreateRevision:
+		_ = b.EncodeVarint(5<<3 | proto.WireVarint)
+		_ = b.EncodeVarint(uint64(x.CreateRevision))
+	case *Compare_ModRevision:
+		_ = b.EncodeVarint(6<<3 | proto.WireVarint)
+		_ = b.EncodeVarint(uint64(x.ModRevision))
+	case *Compare_Value:
+		_ = b.EncodeVarint(7<<3 | proto.WireBytes)
+		_ = b.EncodeRawBytes(x.Value)
+	case *Compare_Lease:
+		_ = b.EncodeVarint(8<<3 | proto.WireVarint)
+		_ = b.EncodeVarint(uint64(x.Lease))
+	case nil:
+	default:
+		return fmt.Errorf("Compare.TargetUnion has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _Compare_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*Compare)
+	switch tag {
+	case 4: // target_union.version
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.TargetUnion = &Compare_Version{int64(x)}
+		return true, err
+	case 5: // target_union.create_revision
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.TargetUnion = &Compare_CreateRevision{int64(x)}
+		return true, err
+	case 6: // target_union.mod_revision
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.TargetUnion = &Compare_ModRevision{int64(x)}
+		return true, err
+	case 7: // target_union.value
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeRawBytes(true)
+		m.TargetUnion = &Compare_Value{x}
+		return true, err
+	case 8: // target_union.lease
+		if wire != proto.WireVarint {
+			return true, proto.ErrInternalBadWireType
+		}
+		x, err := b.DecodeVarint()
+		m.TargetUnion = &Compare_Lease{int64(x)}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _Compare_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*Compare)
+	// target_union
+	switch x := m.TargetUnion.(type) {
+	case *Compare_Version:
+		n += proto.SizeVarint(4<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Version))
+	case *Compare_CreateRevision:
+		n += proto.SizeVarint(5<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.CreateRevision))
+	case *Compare_ModRevision:
+		n += proto.SizeVarint(6<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.ModRevision))
+	case *Compare_Value:
+		n += proto.SizeVarint(7<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(len(x.Value)))
+		n += len(x.Value)
+	case *Compare_Lease:
+		n += proto.SizeVarint(8<<3 | proto.WireVarint)
+		n += proto.SizeVarint(uint64(x.Lease))
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+// From google paxosdb paper:
+// Our implementation hinges around a powerful primitive which we call MultiOp. All other database
+// operations except for iteration are implemented as a single call to MultiOp. A MultiOp is applied atomically
+// and consists of three components:
+// 1. A list of tests called guard. Each test in guard checks a single entry in the database. It may check
+// for the absence or presence of a value, or compare with a given value. Two different tests in the guard
+// may apply to the same or different entries in the database. All tests in the guard are applied and
+// MultiOp returns the results. If all tests are true, MultiOp executes t op (see item 2 below), otherwise
+// it executes f op (see item 3 below).
+// 2. A list of database operations called t op. Each operation in the list is either an insert, delete, or
+// lookup operation, and applies to a single database entry. Two different operations in the list may apply
+// to the same or different entries in the database. These operations are executed
+// if guard evaluates to
+// true.
+// 3. A list of database operations called f op. Like t op, but executed if guard evaluates to false.
+type TxnRequest struct {
+	// compare is a list of predicates representing a conjunction of terms.
+	// If the comparisons succeed, then the success requests will be processed in order,
+	// and the response will contain their respective responses in order.
+	// If the comparisons fail, then the failure requests will be processed in order,
+	// and the response will contain their respective responses in order.
+	Compare []*Compare `protobuf:"bytes,1,rep,name=compare" json:"compare,omitempty"`
+	// success is a list of requests which will be applied when compare evaluates to true.
+	Success []*RequestOp `protobuf:"bytes,2,rep,name=success" json:"success,omitempty"`
+	// failure is a list of requests which will be applied when compare evaluates to false.
+	Failure []*RequestOp `protobuf:"bytes,3,rep,name=failure" json:"failure,omitempty"`
+}
+
+func (m *TxnRequest) Reset()                    { *m = TxnRequest{} }
+func (m *TxnRequest) String() string            { return proto.CompactTextString(m) }
+func (*TxnRequest) ProtoMessage()               {}
+func (*TxnRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{10} }
+
+func (m *TxnRequest) GetCompare() []*Compare {
+	if m != nil {
+		return m.Compare
+	}
+	return nil
+}
+
+func (m *TxnRequest) GetSuccess() []*RequestOp {
+	if m != nil {
+		return m.Success
+	}
+	return nil
+}
+
+func (m *TxnRequest) GetFailure() []*RequestOp {
+	if m != nil {
+		return m.Failure
+	}
+	return nil
+}
+
+type TxnResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// succeeded is set to true if the compare evaluated to true or false otherwise.
+	Succeeded bool `protobuf:"varint,2,opt,name=succeeded,proto3" json:"succeeded,omitempty"`
+	// responses is a list of responses corresponding to the results from applying
+	// success if succeeded is true or failure if succeeded is false.
+	Responses []*ResponseOp `protobuf:"bytes,3,rep,name=responses" json:"responses,omitempty"`
+}
+
+func (m *TxnResponse) Reset()                    { *m = TxnResponse{} }
+func (m *TxnResponse) String() string            { return proto.CompactTextString(m) }
+func (*TxnResponse) ProtoMessage()               {}
+func (*TxnResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{11} }
+
+func (m *TxnResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *TxnResponse) GetSucceeded() bool {
+	if m != nil {
+		return m.Succeeded
+	}
+	return false
+}
+
+func (m *TxnResponse) GetResponses() []*ResponseOp {
+	if m != nil {
+		return m.Responses
+	}
+	return nil
+}
+
+// CompactionRequest compacts the key-value store up to a given revision. All superseded keys
+// with a revision less than the compaction revision will be removed.
+type CompactionRequest struct {
+	// revision is the key-value store revision for the compaction operation.
+	Revision int64 `protobuf:"varint,1,opt,name=revision,proto3" json:"revision,omitempty"`
+	// physical is set so the RPC will wait until the compaction is physically
+	// applied to the local database such that compacted entries are totally
+	// removed from the backend database.
+	Physical bool `protobuf:"varint,2,opt,name=physical,proto3" json:"physical,omitempty"`
+}
+
+func (m *CompactionRequest) Reset()                    { *m = CompactionRequest{} }
+func (m *CompactionRequest) String() string            { return proto.CompactTextString(m) }
+func (*CompactionRequest) ProtoMessage()               {}
+func (*CompactionRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{12} }
+
+func (m *CompactionRequest) GetRevision() int64 {
+	if m != nil {
+		return m.Revision
+	}
+	return 0
+}
+
+func (m *CompactionRequest) GetPhysical() bool {
+	if m != nil {
+		return m.Physical
+	}
+	return false
+}
+
+type CompactionResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *CompactionResponse) Reset()                    { *m = CompactionResponse{} }
+func (m *CompactionResponse) String() string            { return proto.CompactTextString(m) }
+func (*CompactionResponse) ProtoMessage()               {}
+func (*CompactionResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{13} }
+
+func (m *CompactionResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+type HashRequest struct {
+}
+
+func (m *HashRequest) Reset()                    { *m = HashRequest{} }
+func (m *HashRequest) String() string            { return proto.CompactTextString(m) }
+func (*HashRequest) ProtoMessage()               {}
+func (*HashRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{14} }
+
+type HashKVRequest struct {
+	// revision is the key-value store revision for the hash operation.
+	Revision int64 `protobuf:"varint,1,opt,name=revision,proto3" json:"revision,omitempty"`
+}
+
+func (m *HashKVRequest) Reset()                    { *m = HashKVRequest{} }
+func (m *HashKVRequest) String() string            { return proto.CompactTextString(m) }
+func (*HashKVRequest) ProtoMessage()               {}
+func (*HashKVRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{15} }
+
+func (m *HashKVRequest) GetRevision() int64 {
+	if m != nil {
+		return m.Revision
+	}
+	return 0
+}
+
+type HashKVResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// hash is the hash value computed from the responding member's MVCC keys up to a given revision.
+	Hash uint32 `protobuf:"varint,2,opt,name=hash,proto3" json:"hash,omitempty"`
+	// compact_revision is the compacted revision of key-value store when hash begins.
+	CompactRevision int64 `protobuf:"varint,3,opt,name=compact_revision,json=compactRevision,proto3" json:"compact_revision,omitempty"`
+}
+
+func (m *HashKVResponse) Reset()                    { *m = HashKVResponse{} }
+func (m *HashKVResponse) String() string            { return proto.CompactTextString(m) }
+func (*HashKVResponse) ProtoMessage()               {}
+func (*HashKVResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{16} }
+
+func (m *HashKVResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *HashKVResponse) GetHash() uint32 {
+	if m != nil {
+		return m.Hash
+	}
+	return 0
+}
+
+func (m *HashKVResponse) GetCompactRevision() int64 {
+	if m != nil {
+		return m.CompactRevision
+	}
+	return 0
+}
+
+type HashResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// hash is the hash value computed from the responding member's KV's backend.
+	Hash uint32 `protobuf:"varint,2,opt,name=hash,proto3" json:"hash,omitempty"`
+}
+
+func (m *HashResponse) Reset()                    { *m = HashResponse{} }
+func (m *HashResponse) String() string            { return proto.CompactTextString(m) }
+func (*HashResponse) ProtoMessage()               {}
+func (*HashResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{17} }
+
+func (m *HashResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *HashResponse) GetHash() uint32 {
+	if m != nil {
+		return m.Hash
+	}
+	return 0
+}
+
+type SnapshotRequest struct {
+}
+
+func (m *SnapshotRequest) Reset()                    { *m = SnapshotRequest{} }
+func (m *SnapshotRequest) String() string            { return proto.CompactTextString(m) }
+func (*SnapshotRequest) ProtoMessage()               {}
+func (*SnapshotRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{18} }
+
+type SnapshotResponse struct {
+	// header has the current key-value store information. The first header in the snapshot
+	// stream indicates the point in time of the snapshot.
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// remaining_bytes is the number of blob bytes to be sent after this message
+	RemainingBytes uint64 `protobuf:"varint,2,opt,name=remaining_bytes,json=remainingBytes,proto3" json:"remaining_bytes,omitempty"`
+	// blob contains the next chunk of the snapshot in the snapshot stream.
+	Blob []byte `protobuf:"bytes,3,opt,name=blob,proto3" json:"blob,omitempty"`
+}
+
+func (m *SnapshotResponse) Reset()                    { *m = SnapshotResponse{} }
+func (m *SnapshotResponse) String() string            { return proto.CompactTextString(m) }
+func (*SnapshotResponse) ProtoMessage()               {}
+func (*SnapshotResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{19} }
+
+func (m *SnapshotResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *SnapshotResponse) GetRemainingBytes() uint64 {
+	if m != nil {
+		return m.RemainingBytes
+	}
+	return 0
+}
+
+func (m *SnapshotResponse) GetBlob() []byte {
+	if m != nil {
+		return m.Blob
+	}
+	return nil
+}
+
+type WatchRequest struct {
+	// request_union is a request to either create a new watcher or cancel an existing watcher.
+	//
+	// Types that are valid to be assigned to RequestUnion:
+	//	*WatchRequest_CreateRequest
+	//	*WatchRequest_CancelRequest
+	RequestUnion isWatchRequest_RequestUnion `protobuf_oneof:"request_union"`
+}
+
+func (m *WatchRequest) Reset()                    { *m = WatchRequest{} }
+func (m *WatchRequest) String() string            { return proto.CompactTextString(m) }
+func (*WatchRequest) ProtoMessage()               {}
+func (*WatchRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{20} }
+
+type isWatchRequest_RequestUnion interface {
+	isWatchRequest_RequestUnion()
+	MarshalTo([]byte) (int, error)
+	Size() int
+}
+
+type WatchRequest_CreateRequest struct {
+	CreateRequest *WatchCreateRequest `protobuf:"bytes,1,opt,name=create_request,json=createRequest,oneof"`
+}
+type WatchRequest_CancelRequest struct {
+	CancelRequest *WatchCancelRequest `protobuf:"bytes,2,opt,name=cancel_request,json=cancelRequest,oneof"`
+}
+
+func (*WatchRequest_CreateRequest) isWatchRequest_RequestUnion() {}
+func (*WatchRequest_CancelRequest) isWatchRequest_RequestUnion() {}
+
+func (m *WatchRequest) GetRequestUnion() isWatchRequest_RequestUnion {
+	if m != nil {
+		return m.RequestUnion
+	}
+	return nil
+}
+
+func (m *WatchRequest) GetCreateRequest() *WatchCreateRequest {
+	if x, ok := m.GetRequestUnion().(*WatchRequest_CreateRequest); ok {
+		return x.CreateRequest
+	}
+	return nil
+}
+
+func (m *WatchRequest) GetCancelRequest() *WatchCancelRequest {
+	if x, ok := m.GetRequestUnion().(*WatchRequest_CancelRequest); ok {
+		return x.CancelRequest
+	}
+	return nil
+}
+
+// XXX_OneofFuncs is for the internal use of the proto package.
+func (*WatchRequest) XXX_OneofFuncs() (func(msg proto.Message, b *proto.Buffer) error, func(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error), func(msg proto.Message) (n int), []interface{}) {
+	return _WatchRequest_OneofMarshaler, _WatchRequest_OneofUnmarshaler, _WatchRequest_OneofSizer, []interface{}{
+		(*WatchRequest_CreateRequest)(nil),
+		(*WatchRequest_CancelRequest)(nil),
+	}
+}
+
+func _WatchRequest_OneofMarshaler(msg proto.Message, b *proto.Buffer) error {
+	m := msg.(*WatchRequest)
+	// request_union
+	switch x := m.RequestUnion.(type) {
+	case *WatchRequest_CreateRequest:
+		_ = b.EncodeVarint(1<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.CreateRequest); err != nil {
+			return err
+		}
+	case *WatchRequest_CancelRequest:
+		_ = b.EncodeVarint(2<<3 | proto.WireBytes)
+		if err := b.EncodeMessage(x.CancelRequest); err != nil {
+			return err
+		}
+	case nil:
+	default:
+		return fmt.Errorf("WatchRequest.RequestUnion has unexpected type %T", x)
+	}
+	return nil
+}
+
+func _WatchRequest_OneofUnmarshaler(msg proto.Message, tag, wire int, b *proto.Buffer) (bool, error) {
+	m := msg.(*WatchRequest)
+	switch tag {
+	case 1: // request_union.create_request
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(WatchCreateRequest)
+		err := b.DecodeMessage(msg)
+		m.RequestUnion = &WatchRequest_CreateRequest{msg}
+		return true, err
+	case 2: // request_union.cancel_request
+		if wire != proto.WireBytes {
+			return true, proto.ErrInternalBadWireType
+		}
+		msg := new(WatchCancelRequest)
+		err := b.DecodeMessage(msg)
+		m.RequestUnion = &WatchRequest_CancelRequest{msg}
+		return true, err
+	default:
+		return false, nil
+	}
+}
+
+func _WatchRequest_OneofSizer(msg proto.Message) (n int) {
+	m := msg.(*WatchRequest)
+	// request_union
+	switch x := m.RequestUnion.(type) {
+	case *WatchRequest_CreateRequest:
+		s := proto.Size(x.CreateRequest)
+		n += proto.SizeVarint(1<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case *WatchRequest_CancelRequest:
+		s := proto.Size(x.CancelRequest)
+		n += proto.SizeVarint(2<<3 | proto.WireBytes)
+		n += proto.SizeVarint(uint64(s))
+		n += s
+	case nil:
+	default:
+		panic(fmt.Sprintf("proto: unexpected type %T in oneof", x))
+	}
+	return n
+}
+
+type WatchCreateRequest struct {
+	// key is the key to register for watching.
+	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	// range_end is the end of the range [key, range_end) to watch. If range_end is not given,
+	// only the key argument is watched. If range_end is equal to '\0', all keys greater than
+	// or equal to the key argument are watched.
+	// If the range_end is one bit larger than the given key,
+	// then all keys with the prefix (the given key) will be watched.
+	RangeEnd []byte `protobuf:"bytes,2,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
+	// start_revision is an optional revision to watch from (inclusive). No start_revision is "now".
+	StartRevision int64 `protobuf:"varint,3,opt,name=start_revision,json=startRevision,proto3" json:"start_revision,omitempty"`
+	// progress_notify is set so that the etcd server will periodically send a WatchResponse with
+	// no events to the new watcher if there are no recent events. It is useful when clients
+	// wish to recover a disconnected watcher starting from a recent known revision.
+	// The etcd server may decide how often it will send notifications based on current load.
+	ProgressNotify bool `protobuf:"varint,4,opt,name=progress_notify,json=progressNotify,proto3" json:"progress_notify,omitempty"`
+	// filters filter the events at server side before it sends back to the watcher.
+	Filters []WatchCreateRequest_FilterType `protobuf:"varint,5,rep,packed,name=filters,enum=etcdserverpb.WatchCreateRequest_FilterType" json:"filters,omitempty"`
+	// If prev_kv is set, created watcher gets the previous KV before the event happens.
+	// If the previous KV is already compacted, nothing will be returned.
+	PrevKv bool `protobuf:"varint,6,opt,name=prev_kv,json=prevKv,proto3" json:"prev_kv,omitempty"`
+}
+
+func (m *WatchCreateRequest) Reset()                    { *m = WatchCreateRequest{} }
+func (m *WatchCreateRequest) String() string            { return proto.CompactTextString(m) }
+func (*WatchCreateRequest) ProtoMessage()               {}
+func (*WatchCreateRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{21} }
+
+func (m *WatchCreateRequest) GetKey() []byte {
+	if m != nil {
+		return m.Key
+	}
+	return nil
+}
+
+func (m *WatchCreateRequest) GetRangeEnd() []byte {
+	if m != nil {
+		return m.RangeEnd
+	}
+	return nil
+}
+
+func (m *WatchCreateRequest) GetStartRevision() int64 {
+	if m != nil {
+		return m.StartRevision
+	}
+	return 0
+}
+
+func (m *WatchCreateRequest) GetProgressNotify() bool {
+	if m != nil {
+		return m.ProgressNotify
+	}
+	return false
+}
+
+func (m *WatchCreateRequest) GetFilters() []WatchCreateRequest_FilterType {
+	if m != nil {
+		return m.Filters
+	}
+	return nil
+}
+
+func (m *WatchCreateRequest) GetPrevKv() bool {
+	if m != nil {
+		return m.PrevKv
+	}
+	return false
+}
+
+type WatchCancelRequest struct {
+	// watch_id is the watcher id to cancel so that no more events are transmitted.
+	WatchId int64 `protobuf:"varint,1,opt,name=watch_id,json=watchId,proto3" json:"watch_id,omitempty"`
+}
+
+func (m *WatchCancelRequest) Reset()                    { *m = WatchCancelRequest{} }
+func (m *WatchCancelRequest) String() string            { return proto.CompactTextString(m) }
+func (*WatchCancelRequest) ProtoMessage()               {}
+func (*WatchCancelRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{22} }
+
+func (m *WatchCancelRequest) GetWatchId() int64 {
+	if m != nil {
+		return m.WatchId
+	}
+	return 0
+}
+
+type WatchResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// watch_id is the ID of the watcher that corresponds to the response.
+	WatchId int64 `protobuf:"varint,2,opt,name=watch_id,json=watchId,proto3" json:"watch_id,omitempty"`
+	// created is set to true if the response is for a create watch request.
+	// The client should record the watch_id and expect to receive events for
+	// the created watcher from the same stream.
+	// All events sent to the created watcher will attach with the same watch_id.
+	Created bool `protobuf:"varint,3,opt,name=created,proto3" json:"created,omitempty"`
+	// canceled is set to true if the response is for a cancel watch request.
+	// No further events will be sent to the canceled watcher.
+	Canceled bool `protobuf:"varint,4,opt,name=canceled,proto3" json:"canceled,omitempty"`
+	// compact_revision is set to the minimum index if a watcher tries to watch
+	// at a compacted index.
+	//
+	// This happens when creating a watcher at a compacted revision or the watcher cannot
+	// catch up with the progress of the key-value store.
+	//
+	// The client should treat the watcher as canceled and should not try to create any
+	// watcher with the same start_revision again.
+	CompactRevision int64 `protobuf:"varint,5,opt,name=compact_revision,json=compactRevision,proto3" json:"compact_revision,omitempty"`
+	// cancel_reason indicates the reason for canceling the watcher.
+	CancelReason string          `protobuf:"bytes,6,opt,name=cancel_reason,json=cancelReason,proto3" json:"cancel_reason,omitempty"`
+	Events       []*mvccpb.Event `protobuf:"bytes,11,rep,name=events" json:"events,omitempty"`
+}
+
+func (m *WatchResponse) Reset()                    { *m = WatchResponse{} }
+func (m *WatchResponse) String() string            { return proto.CompactTextString(m) }
+func (*WatchResponse) ProtoMessage()               {}
+func (*WatchResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{23} }
+
+func (m *WatchResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *WatchResponse) GetWatchId() int64 {
+	if m != nil {
+		return m.WatchId
+	}
+	return 0
+}
+
+func (m *WatchResponse) GetCreated() bool {
+	if m != nil {
+		return m.Created
+	}
+	return false
+}
+
+func (m *WatchResponse) GetCanceled() bool {
+	if m != nil {
+		return m.Canceled
+	}
+	return false
+}
+
+func (m *WatchResponse) GetCompactRevision() int64 {
+	if m != nil {
+		return m.CompactRevision
+	}
+	return 0
+}
+
+func (m *WatchResponse) GetCancelReason() string {
+	if m != nil {
+		return m.CancelReason
+	}
+	return ""
+}
+
+func (m *WatchResponse) GetEvents() []*mvccpb.Event {
+	if m != nil {
+		return m.Events
+	}
+	return nil
+}
+
+type LeaseGrantRequest struct {
+	// TTL is the advisory time-to-live in seconds.
+	TTL int64 `protobuf:"varint,1,opt,name=TTL,proto3" json:"TTL,omitempty"`
+	// ID is the requested ID for the lease. If ID is set to 0, the lessor chooses an ID.
+	ID int64 `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
+}
+
+func (m *LeaseGrantRequest) Reset()                    { *m = LeaseGrantRequest{} }
+func (m *LeaseGrantRequest) String() string            { return proto.CompactTextString(m) }
+func (*LeaseGrantRequest) ProtoMessage()               {}
+func (*LeaseGrantRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{24} }
+
+func (m *LeaseGrantRequest) GetTTL() int64 {
+	if m != nil {
+		return m.TTL
+	}
+	return 0
+}
+
+func (m *LeaseGrantRequest) GetID() int64 {
+	if m != nil {
+		return m.ID
+	}
+	return 0
+}
+
+type LeaseGrantResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// ID is the lease ID for the granted lease.
+	ID int64 `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
+	// TTL is the server chosen lease time-to-live in seconds.
+	TTL   int64  `protobuf:"varint,3,opt,name=TTL,proto3" json:"TTL,omitempty"`
+	Error string `protobuf:"bytes,4,opt,name=error,proto3" json:"error,omitempty"`
+}
+
+func (m *LeaseGrantResponse) Reset()                    { *m = LeaseGrantResponse{} }
+func (m *LeaseGrantResponse) String() string            { return proto.CompactTextString(m) }
+func (*LeaseGrantResponse) ProtoMessage()               {}
+func (*LeaseGrantResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{25} }
+
+func (m *LeaseGrantResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *LeaseGrantResponse) GetID() int64 {
+	if m != nil {
+		return m.ID
+	}
+	return 0
+}
+
+func (m *LeaseGrantResponse) GetTTL() int64 {
+	if m != nil {
+		return m.TTL
+	}
+	return 0
+}
+
+func (m *LeaseGrantResponse) GetError() string {
+	if m != nil {
+		return m.Error
+	}
+	return ""
+}
+
+type LeaseRevokeRequest struct {
+	// ID is the lease ID to revoke. When the ID is revoked, all associated keys will be deleted.
+	ID int64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
+}
+
+func (m *LeaseRevokeRequest) Reset()                    { *m = LeaseRevokeRequest{} }
+func (m *LeaseRevokeRequest) String() string            { return proto.CompactTextString(m) }
+func (*LeaseRevokeRequest) ProtoMessage()               {}
+func (*LeaseRevokeRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{26} }
+
+func (m *LeaseRevokeRequest) GetID() int64 {
+	if m != nil {
+		return m.ID
+	}
+	return 0
+}
+
+type LeaseRevokeResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *LeaseRevokeResponse) Reset()                    { *m = LeaseRevokeResponse{} }
+func (m *LeaseRevokeResponse) String() string            { return proto.CompactTextString(m) }
+func (*LeaseRevokeResponse) ProtoMessage()               {}
+func (*LeaseRevokeResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{27} }
+
+func (m *LeaseRevokeResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+type LeaseKeepAliveRequest struct {
+	// ID is the lease ID for the lease to keep alive.
+	ID int64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
+}
+
+func (m *LeaseKeepAliveRequest) Reset()                    { *m = LeaseKeepAliveRequest{} }
+func (m *LeaseKeepAliveRequest) String() string            { return proto.CompactTextString(m) }
+func (*LeaseKeepAliveRequest) ProtoMessage()               {}
+func (*LeaseKeepAliveRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{28} }
+
+func (m *LeaseKeepAliveRequest) GetID() int64 {
+	if m != nil {
+		return m.ID
+	}
+	return 0
+}
+
+type LeaseKeepAliveResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// ID is the lease ID from the keep alive request.
+	ID int64 `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
+	// TTL is the new time-to-live for the lease.
+	TTL int64 `protobuf:"varint,3,opt,name=TTL,proto3" json:"TTL,omitempty"`
+}
+
+func (m *LeaseKeepAliveResponse) Reset()                    { *m = LeaseKeepAliveResponse{} }
+func (m *LeaseKeepAliveResponse) String() string            { return proto.CompactTextString(m) }
+func (*LeaseKeepAliveResponse) ProtoMessage()               {}
+func (*LeaseKeepAliveResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{29} }
+
+func (m *LeaseKeepAliveResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *LeaseKeepAliveResponse) GetID() int64 {
+	if m != nil {
+		return m.ID
+	}
+	return 0
+}
+
+func (m *LeaseKeepAliveResponse) GetTTL() int64 {
+	if m != nil {
+		return m.TTL
+	}
+	return 0
+}
+
+type LeaseTimeToLiveRequest struct {
+	// ID is the lease ID for the lease.
+	ID int64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
+	// keys is true to query all the keys attached to this lease.
+	Keys bool `protobuf:"varint,2,opt,name=keys,proto3" json:"keys,omitempty"`
+}
+
+func (m *LeaseTimeToLiveRequest) Reset()                    { *m = LeaseTimeToLiveRequest{} }
+func (m *LeaseTimeToLiveRequest) String() string            { return proto.CompactTextString(m) }
+func (*LeaseTimeToLiveRequest) ProtoMessage()               {}
+func (*LeaseTimeToLiveRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{30} }
+
+func (m *LeaseTimeToLiveRequest) GetID() int64 {
+	if m != nil {
+		return m.ID
+	}
+	return 0
+}
+
+func (m *LeaseTimeToLiveRequest) GetKeys() bool {
+	if m != nil {
+		return m.Keys
+	}
+	return false
+}
+
+type LeaseTimeToLiveResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// ID is the lease ID from the keep alive request.
+	ID int64 `protobuf:"varint,2,opt,name=ID,proto3" json:"ID,omitempty"`
+	// TTL is the remaining TTL in seconds for the lease; the lease will expire in under TTL+1 seconds.
+	TTL int64 `protobuf:"varint,3,opt,name=TTL,proto3" json:"TTL,omitempty"`
+	// GrantedTTL is the initial granted time in seconds upon lease creation/renewal.
+	GrantedTTL int64 `protobuf:"varint,4,opt,name=grantedTTL,proto3" json:"grantedTTL,omitempty"`
+	// Keys is the list of keys attached to this lease.
+	Keys [][]byte `protobuf:"bytes,5,rep,name=keys" json:"keys,omitempty"`
+}
+
+func (m *LeaseTimeToLiveResponse) Reset()                    { *m = LeaseTimeToLiveResponse{} }
+func (m *LeaseTimeToLiveResponse) String() string            { return proto.CompactTextString(m) }
+func (*LeaseTimeToLiveResponse) ProtoMessage()               {}
+func (*LeaseTimeToLiveResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{31} }
+
+func (m *LeaseTimeToLiveResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *LeaseTimeToLiveResponse) GetID() int64 {
+	if m != nil {
+		return m.ID
+	}
+	return 0
+}
+
+func (m *LeaseTimeToLiveResponse) GetTTL() int64 {
+	if m != nil {
+		return m.TTL
+	}
+	return 0
+}
+
+func (m *LeaseTimeToLiveResponse) GetGrantedTTL() int64 {
+	if m != nil {
+		return m.GrantedTTL
+	}
+	return 0
+}
+
+func (m *LeaseTimeToLiveResponse) GetKeys() [][]byte {
+	if m != nil {
+		return m.Keys
+	}
+	return nil
+}
+
+type LeaseLeasesRequest struct {
+}
+
+func (m *LeaseLeasesRequest) Reset()                    { *m = LeaseLeasesRequest{} }
+func (m *LeaseLeasesRequest) String() string            { return proto.CompactTextString(m) }
+func (*LeaseLeasesRequest) ProtoMessage()               {}
+func (*LeaseLeasesRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{32} }
+
+type LeaseStatus struct {
+	ID int64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
+}
+
+func (m *LeaseStatus) Reset()                    { *m = LeaseStatus{} }
+func (m *LeaseStatus) String() string            { return proto.CompactTextString(m) }
+func (*LeaseStatus) ProtoMessage()               {}
+func (*LeaseStatus) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{33} }
+
+func (m *LeaseStatus) GetID() int64 {
+	if m != nil {
+		return m.ID
+	}
+	return 0
+}
+
+type LeaseLeasesResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	Leases []*LeaseStatus  `protobuf:"bytes,2,rep,name=leases" json:"leases,omitempty"`
+}
+
+func (m *LeaseLeasesResponse) Reset()                    { *m = LeaseLeasesResponse{} }
+func (m *LeaseLeasesResponse) String() string            { return proto.CompactTextString(m) }
+func (*LeaseLeasesResponse) ProtoMessage()               {}
+func (*LeaseLeasesResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{34} }
+
+func (m *LeaseLeasesResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *LeaseLeasesResponse) GetLeases() []*LeaseStatus {
+	if m != nil {
+		return m.Leases
+	}
+	return nil
+}
+
+type Member struct {
+	// ID is the member ID for this member.
+	ID uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
+	// name is the human-readable name of the member. If the member is not started, the name will be an empty string.
+	Name string `protobuf:"bytes,2,opt,name=name,proto3" json:"name,omitempty"`
+	// peerURLs is the list of URLs the member exposes to the cluster for communication.
+	PeerURLs []string `protobuf:"bytes,3,rep,name=peerURLs" json:"peerURLs,omitempty"`
+	// clientURLs is the list of URLs the member exposes to clients for communication. If the member is not started, clientURLs will be empty.
+	ClientURLs []string `protobuf:"bytes,4,rep,name=clientURLs" json:"clientURLs,omitempty"`
+}
+
+func (m *Member) Reset()                    { *m = Member{} }
+func (m *Member) String() string            { return proto.CompactTextString(m) }
+func (*Member) ProtoMessage()               {}
+func (*Member) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{35} }
+
+func (m *Member) GetID() uint64 {
+	if m != nil {
+		return m.ID
+	}
+	return 0
+}
+
+func (m *Member) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *Member) GetPeerURLs() []string {
+	if m != nil {
+		return m.PeerURLs
+	}
+	return nil
+}
+
+func (m *Member) GetClientURLs() []string {
+	if m != nil {
+		return m.ClientURLs
+	}
+	return nil
+}
+
+type MemberAddRequest struct {
+	// peerURLs is the list of URLs the added member will use to communicate with the cluster.
+	PeerURLs []string `protobuf:"bytes,1,rep,name=peerURLs" json:"peerURLs,omitempty"`
+}
+
+func (m *MemberAddRequest) Reset()                    { *m = MemberAddRequest{} }
+func (m *MemberAddRequest) String() string            { return proto.CompactTextString(m) }
+func (*MemberAddRequest) ProtoMessage()               {}
+func (*MemberAddRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{36} }
+
+func (m *MemberAddRequest) GetPeerURLs() []string {
+	if m != nil {
+		return m.PeerURLs
+	}
+	return nil
+}
+
+type MemberAddResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// member is the member information for the added member.
+	Member *Member `protobuf:"bytes,2,opt,name=member" json:"member,omitempty"`
+	// members is a list of all members after adding the new member.
+	Members []*Member `protobuf:"bytes,3,rep,name=members" json:"members,omitempty"`
+}
+
+func (m *MemberAddResponse) Reset()                    { *m = MemberAddResponse{} }
+func (m *MemberAddResponse) String() string            { return proto.CompactTextString(m) }
+func (*MemberAddResponse) ProtoMessage()               {}
+func (*MemberAddResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{37} }
+
+func (m *MemberAddResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *MemberAddResponse) GetMember() *Member {
+	if m != nil {
+		return m.Member
+	}
+	return nil
+}
+
+func (m *MemberAddResponse) GetMembers() []*Member {
+	if m != nil {
+		return m.Members
+	}
+	return nil
+}
+
+type MemberRemoveRequest struct {
+	// ID is the member ID of the member to remove.
+	ID uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
+}
+
+func (m *MemberRemoveRequest) Reset()                    { *m = MemberRemoveRequest{} }
+func (m *MemberRemoveRequest) String() string            { return proto.CompactTextString(m) }
+func (*MemberRemoveRequest) ProtoMessage()               {}
+func (*MemberRemoveRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{38} }
+
+func (m *MemberRemoveRequest) GetID() uint64 {
+	if m != nil {
+		return m.ID
+	}
+	return 0
+}
+
+type MemberRemoveResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// members is a list of all members after removing the member.
+	Members []*Member `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"`
+}
+
+func (m *MemberRemoveResponse) Reset()                    { *m = MemberRemoveResponse{} }
+func (m *MemberRemoveResponse) String() string            { return proto.CompactTextString(m) }
+func (*MemberRemoveResponse) ProtoMessage()               {}
+func (*MemberRemoveResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{39} }
+
+func (m *MemberRemoveResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *MemberRemoveResponse) GetMembers() []*Member {
+	if m != nil {
+		return m.Members
+	}
+	return nil
+}
+
+type MemberUpdateRequest struct {
+	// ID is the member ID of the member to update.
+	ID uint64 `protobuf:"varint,1,opt,name=ID,proto3" json:"ID,omitempty"`
+	// peerURLs is the new list of URLs the member will use to communicate with the cluster.
+	PeerURLs []string `protobuf:"bytes,2,rep,name=peerURLs" json:"peerURLs,omitempty"`
+}
+
+func (m *MemberUpdateRequest) Reset()                    { *m = MemberUpdateRequest{} }
+func (m *MemberUpdateRequest) String() string            { return proto.CompactTextString(m) }
+func (*MemberUpdateRequest) ProtoMessage()               {}
+func (*MemberUpdateRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{40} }
+
+func (m *MemberUpdateRequest) GetID() uint64 {
+	if m != nil {
+		return m.ID
+	}
+	return 0
+}
+
+func (m *MemberUpdateRequest) GetPeerURLs() []string {
+	if m != nil {
+		return m.PeerURLs
+	}
+	return nil
+}
+
+type MemberUpdateResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// members is a list of all members after updating the member.
+	Members []*Member `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"`
+}
+
+func (m *MemberUpdateResponse) Reset()                    { *m = MemberUpdateResponse{} }
+func (m *MemberUpdateResponse) String() string            { return proto.CompactTextString(m) }
+func (*MemberUpdateResponse) ProtoMessage()               {}
+func (*MemberUpdateResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{41} }
+
+func (m *MemberUpdateResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *MemberUpdateResponse) GetMembers() []*Member {
+	if m != nil {
+		return m.Members
+	}
+	return nil
+}
+
+type MemberListRequest struct {
+}
+
+func (m *MemberListRequest) Reset()                    { *m = MemberListRequest{} }
+func (m *MemberListRequest) String() string            { return proto.CompactTextString(m) }
+func (*MemberListRequest) ProtoMessage()               {}
+func (*MemberListRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{42} }
+
+type MemberListResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// members is a list of all members associated with the cluster.
+	Members []*Member `protobuf:"bytes,2,rep,name=members" json:"members,omitempty"`
+}
+
+func (m *MemberListResponse) Reset()                    { *m = MemberListResponse{} }
+func (m *MemberListResponse) String() string            { return proto.CompactTextString(m) }
+func (*MemberListResponse) ProtoMessage()               {}
+func (*MemberListResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{43} }
+
+func (m *MemberListResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *MemberListResponse) GetMembers() []*Member {
+	if m != nil {
+		return m.Members
+	}
+	return nil
+}
+
+type DefragmentRequest struct {
+}
+
+func (m *DefragmentRequest) Reset()                    { *m = DefragmentRequest{} }
+func (m *DefragmentRequest) String() string            { return proto.CompactTextString(m) }
+func (*DefragmentRequest) ProtoMessage()               {}
+func (*DefragmentRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{44} }
+
+type DefragmentResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *DefragmentResponse) Reset()                    { *m = DefragmentResponse{} }
+func (m *DefragmentResponse) String() string            { return proto.CompactTextString(m) }
+func (*DefragmentResponse) ProtoMessage()               {}
+func (*DefragmentResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{45} }
+
+func (m *DefragmentResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+type MoveLeaderRequest struct {
+	// targetID is the node ID for the new leader.
+	TargetID uint64 `protobuf:"varint,1,opt,name=targetID,proto3" json:"targetID,omitempty"`
+}
+
+func (m *MoveLeaderRequest) Reset()                    { *m = MoveLeaderRequest{} }
+func (m *MoveLeaderRequest) String() string            { return proto.CompactTextString(m) }
+func (*MoveLeaderRequest) ProtoMessage()               {}
+func (*MoveLeaderRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{46} }
+
+func (m *MoveLeaderRequest) GetTargetID() uint64 {
+	if m != nil {
+		return m.TargetID
+	}
+	return 0
+}
+
+type MoveLeaderResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *MoveLeaderResponse) Reset()                    { *m = MoveLeaderResponse{} }
+func (m *MoveLeaderResponse) String() string            { return proto.CompactTextString(m) }
+func (*MoveLeaderResponse) ProtoMessage()               {}
+func (*MoveLeaderResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{47} }
+
+func (m *MoveLeaderResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+type AlarmRequest struct {
+	// action is the kind of alarm request to issue. The action
+	// may GET alarm statuses, ACTIVATE an alarm, or DEACTIVATE a
+	// raised alarm.
+	Action AlarmRequest_AlarmAction `protobuf:"varint,1,opt,name=action,proto3,enum=etcdserverpb.AlarmRequest_AlarmAction" json:"action,omitempty"`
+	// memberID is the ID of the member associated with the alarm. If memberID is 0, the
+	// alarm request covers all members.
+	MemberID uint64 `protobuf:"varint,2,opt,name=memberID,proto3" json:"memberID,omitempty"`
+	// alarm is the type of alarm to consider for this request.
+	Alarm AlarmType `protobuf:"varint,3,opt,name=alarm,proto3,enum=etcdserverpb.AlarmType" json:"alarm,omitempty"`
+}
+
+func (m *AlarmRequest) Reset()                    { *m = AlarmRequest{} }
+func (m *AlarmRequest) String() string            { return proto.CompactTextString(m) }
+func (*AlarmRequest) ProtoMessage()               {}
+func (*AlarmRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{48} }
+
+func (m *AlarmRequest) GetAction() AlarmRequest_AlarmAction {
+	if m != nil {
+		return m.Action
+	}
+	return AlarmRequest_GET
+}
+
+func (m *AlarmRequest) GetMemberID() uint64 {
+	if m != nil {
+		return m.MemberID
+	}
+	return 0
+}
+
+func (m *AlarmRequest) GetAlarm() AlarmType {
+	if m != nil {
+		return m.Alarm
+	}
+	return AlarmType_NONE
+}
+
+type AlarmMember struct {
+	// memberID is the ID of the member associated with the raised alarm.
+	MemberID uint64 `protobuf:"varint,1,opt,name=memberID,proto3" json:"memberID,omitempty"`
+	// alarm is the type of alarm which has been raised.
+	Alarm AlarmType `protobuf:"varint,2,opt,name=alarm,proto3,enum=etcdserverpb.AlarmType" json:"alarm,omitempty"`
+}
+
+func (m *AlarmMember) Reset()                    { *m = AlarmMember{} }
+func (m *AlarmMember) String() string            { return proto.CompactTextString(m) }
+func (*AlarmMember) ProtoMessage()               {}
+func (*AlarmMember) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{49} }
+
+func (m *AlarmMember) GetMemberID() uint64 {
+	if m != nil {
+		return m.MemberID
+	}
+	return 0
+}
+
+func (m *AlarmMember) GetAlarm() AlarmType {
+	if m != nil {
+		return m.Alarm
+	}
+	return AlarmType_NONE
+}
+
+type AlarmResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// alarms is a list of alarms associated with the alarm request.
+	Alarms []*AlarmMember `protobuf:"bytes,2,rep,name=alarms" json:"alarms,omitempty"`
+}
+
+func (m *AlarmResponse) Reset()                    { *m = AlarmResponse{} }
+func (m *AlarmResponse) String() string            { return proto.CompactTextString(m) }
+func (*AlarmResponse) ProtoMessage()               {}
+func (*AlarmResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{50} }
+
+func (m *AlarmResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *AlarmResponse) GetAlarms() []*AlarmMember {
+	if m != nil {
+		return m.Alarms
+	}
+	return nil
+}
+
+type StatusRequest struct {
+}
+
+func (m *StatusRequest) Reset()                    { *m = StatusRequest{} }
+func (m *StatusRequest) String() string            { return proto.CompactTextString(m) }
+func (*StatusRequest) ProtoMessage()               {}
+func (*StatusRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{51} }
+
+type StatusResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// version is the cluster protocol version used by the responding member.
+	Version string `protobuf:"bytes,2,opt,name=version,proto3" json:"version,omitempty"`
+	// dbSize is the size of the backend database, in bytes, of the responding member.
+	DbSize int64 `protobuf:"varint,3,opt,name=dbSize,proto3" json:"dbSize,omitempty"`
+	// leader is the member ID which the responding member believes is the current leader.
+	Leader uint64 `protobuf:"varint,4,opt,name=leader,proto3" json:"leader,omitempty"`
+	// raftIndex is the current raft index of the responding member.
+	RaftIndex uint64 `protobuf:"varint,5,opt,name=raftIndex,proto3" json:"raftIndex,omitempty"`
+	// raftTerm is the current raft term of the responding member.
+	RaftTerm uint64 `protobuf:"varint,6,opt,name=raftTerm,proto3" json:"raftTerm,omitempty"`
+}
+
+func (m *StatusResponse) Reset()                    { *m = StatusResponse{} }
+func (m *StatusResponse) String() string            { return proto.CompactTextString(m) }
+func (*StatusResponse) ProtoMessage()               {}
+func (*StatusResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{52} }
+
+func (m *StatusResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *StatusResponse) GetVersion() string {
+	if m != nil {
+		return m.Version
+	}
+	return ""
+}
+
+func (m *StatusResponse) GetDbSize() int64 {
+	if m != nil {
+		return m.DbSize
+	}
+	return 0
+}
+
+func (m *StatusResponse) GetLeader() uint64 {
+	if m != nil {
+		return m.Leader
+	}
+	return 0
+}
+
+func (m *StatusResponse) GetRaftIndex() uint64 {
+	if m != nil {
+		return m.RaftIndex
+	}
+	return 0
+}
+
+func (m *StatusResponse) GetRaftTerm() uint64 {
+	if m != nil {
+		return m.RaftTerm
+	}
+	return 0
+}
+
+type AuthEnableRequest struct {
+}
+
+func (m *AuthEnableRequest) Reset()                    { *m = AuthEnableRequest{} }
+func (m *AuthEnableRequest) String() string            { return proto.CompactTextString(m) }
+func (*AuthEnableRequest) ProtoMessage()               {}
+func (*AuthEnableRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{53} }
+
+type AuthDisableRequest struct {
+}
+
+func (m *AuthDisableRequest) Reset()                    { *m = AuthDisableRequest{} }
+func (m *AuthDisableRequest) String() string            { return proto.CompactTextString(m) }
+func (*AuthDisableRequest) ProtoMessage()               {}
+func (*AuthDisableRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{54} }
+
+type AuthenticateRequest struct {
+	Name     string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
+}
+
+func (m *AuthenticateRequest) Reset()                    { *m = AuthenticateRequest{} }
+func (m *AuthenticateRequest) String() string            { return proto.CompactTextString(m) }
+func (*AuthenticateRequest) ProtoMessage()               {}
+func (*AuthenticateRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{55} }
+
+func (m *AuthenticateRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *AuthenticateRequest) GetPassword() string {
+	if m != nil {
+		return m.Password
+	}
+	return ""
+}
+
+type AuthUserAddRequest struct {
+	Name     string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
+}
+
+func (m *AuthUserAddRequest) Reset()                    { *m = AuthUserAddRequest{} }
+func (m *AuthUserAddRequest) String() string            { return proto.CompactTextString(m) }
+func (*AuthUserAddRequest) ProtoMessage()               {}
+func (*AuthUserAddRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{56} }
+
+func (m *AuthUserAddRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *AuthUserAddRequest) GetPassword() string {
+	if m != nil {
+		return m.Password
+	}
+	return ""
+}
+
+type AuthUserGetRequest struct {
+	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+}
+
+func (m *AuthUserGetRequest) Reset()                    { *m = AuthUserGetRequest{} }
+func (m *AuthUserGetRequest) String() string            { return proto.CompactTextString(m) }
+func (*AuthUserGetRequest) ProtoMessage()               {}
+func (*AuthUserGetRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{57} }
+
+func (m *AuthUserGetRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+type AuthUserDeleteRequest struct {
+	// name is the name of the user to delete.
+	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+}
+
+func (m *AuthUserDeleteRequest) Reset()                    { *m = AuthUserDeleteRequest{} }
+func (m *AuthUserDeleteRequest) String() string            { return proto.CompactTextString(m) }
+func (*AuthUserDeleteRequest) ProtoMessage()               {}
+func (*AuthUserDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{58} }
+
+func (m *AuthUserDeleteRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+type AuthUserChangePasswordRequest struct {
+	// name is the name of the user whose password is being changed.
+	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	// password is the new password for the user.
+	Password string `protobuf:"bytes,2,opt,name=password,proto3" json:"password,omitempty"`
+}
+
+func (m *AuthUserChangePasswordRequest) Reset()         { *m = AuthUserChangePasswordRequest{} }
+func (m *AuthUserChangePasswordRequest) String() string { return proto.CompactTextString(m) }
+func (*AuthUserChangePasswordRequest) ProtoMessage()    {}
+func (*AuthUserChangePasswordRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptorRpc, []int{59}
+}
+
+func (m *AuthUserChangePasswordRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *AuthUserChangePasswordRequest) GetPassword() string {
+	if m != nil {
+		return m.Password
+	}
+	return ""
+}
+
+type AuthUserGrantRoleRequest struct {
+	// user is the name of the user which should be granted a given role.
+	User string `protobuf:"bytes,1,opt,name=user,proto3" json:"user,omitempty"`
+	// role is the name of the role to grant to the user.
+	Role string `protobuf:"bytes,2,opt,name=role,proto3" json:"role,omitempty"`
+}
+
+func (m *AuthUserGrantRoleRequest) Reset()                    { *m = AuthUserGrantRoleRequest{} }
+func (m *AuthUserGrantRoleRequest) String() string            { return proto.CompactTextString(m) }
+func (*AuthUserGrantRoleRequest) ProtoMessage()               {}
+func (*AuthUserGrantRoleRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{60} }
+
+func (m *AuthUserGrantRoleRequest) GetUser() string {
+	if m != nil {
+		return m.User
+	}
+	return ""
+}
+
+func (m *AuthUserGrantRoleRequest) GetRole() string {
+	if m != nil {
+		return m.Role
+	}
+	return ""
+}
+
+type AuthUserRevokeRoleRequest struct {
+	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	Role string `protobuf:"bytes,2,opt,name=role,proto3" json:"role,omitempty"`
+}
+
+func (m *AuthUserRevokeRoleRequest) Reset()                    { *m = AuthUserRevokeRoleRequest{} }
+func (m *AuthUserRevokeRoleRequest) String() string            { return proto.CompactTextString(m) }
+func (*AuthUserRevokeRoleRequest) ProtoMessage()               {}
+func (*AuthUserRevokeRoleRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{61} }
+
+func (m *AuthUserRevokeRoleRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *AuthUserRevokeRoleRequest) GetRole() string {
+	if m != nil {
+		return m.Role
+	}
+	return ""
+}
+
+type AuthRoleAddRequest struct {
+	// name is the name of the role to add to the authentication system.
+	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+}
+
+func (m *AuthRoleAddRequest) Reset()                    { *m = AuthRoleAddRequest{} }
+func (m *AuthRoleAddRequest) String() string            { return proto.CompactTextString(m) }
+func (*AuthRoleAddRequest) ProtoMessage()               {}
+func (*AuthRoleAddRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{62} }
+
+func (m *AuthRoleAddRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+type AuthRoleGetRequest struct {
+	Role string `protobuf:"bytes,1,opt,name=role,proto3" json:"role,omitempty"`
+}
+
+func (m *AuthRoleGetRequest) Reset()                    { *m = AuthRoleGetRequest{} }
+func (m *AuthRoleGetRequest) String() string            { return proto.CompactTextString(m) }
+func (*AuthRoleGetRequest) ProtoMessage()               {}
+func (*AuthRoleGetRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{63} }
+
+func (m *AuthRoleGetRequest) GetRole() string {
+	if m != nil {
+		return m.Role
+	}
+	return ""
+}
+
+type AuthUserListRequest struct {
+}
+
+func (m *AuthUserListRequest) Reset()                    { *m = AuthUserListRequest{} }
+func (m *AuthUserListRequest) String() string            { return proto.CompactTextString(m) }
+func (*AuthUserListRequest) ProtoMessage()               {}
+func (*AuthUserListRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{64} }
+
+type AuthRoleListRequest struct {
+}
+
+func (m *AuthRoleListRequest) Reset()                    { *m = AuthRoleListRequest{} }
+func (m *AuthRoleListRequest) String() string            { return proto.CompactTextString(m) }
+func (*AuthRoleListRequest) ProtoMessage()               {}
+func (*AuthRoleListRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{65} }
+
+type AuthRoleDeleteRequest struct {
+	Role string `protobuf:"bytes,1,opt,name=role,proto3" json:"role,omitempty"`
+}
+
+func (m *AuthRoleDeleteRequest) Reset()                    { *m = AuthRoleDeleteRequest{} }
+func (m *AuthRoleDeleteRequest) String() string            { return proto.CompactTextString(m) }
+func (*AuthRoleDeleteRequest) ProtoMessage()               {}
+func (*AuthRoleDeleteRequest) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{66} }
+
+func (m *AuthRoleDeleteRequest) GetRole() string {
+	if m != nil {
+		return m.Role
+	}
+	return ""
+}
+
+type AuthRoleGrantPermissionRequest struct {
+	// name is the name of the role which will be granted the permission.
+	Name string `protobuf:"bytes,1,opt,name=name,proto3" json:"name,omitempty"`
+	// perm is the permission to grant to the role.
+	Perm *authpb.Permission `protobuf:"bytes,2,opt,name=perm" json:"perm,omitempty"`
+}
+
+func (m *AuthRoleGrantPermissionRequest) Reset()         { *m = AuthRoleGrantPermissionRequest{} }
+func (m *AuthRoleGrantPermissionRequest) String() string { return proto.CompactTextString(m) }
+func (*AuthRoleGrantPermissionRequest) ProtoMessage()    {}
+func (*AuthRoleGrantPermissionRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptorRpc, []int{67}
+}
+
+func (m *AuthRoleGrantPermissionRequest) GetName() string {
+	if m != nil {
+		return m.Name
+	}
+	return ""
+}
+
+func (m *AuthRoleGrantPermissionRequest) GetPerm() *authpb.Permission {
+	if m != nil {
+		return m.Perm
+	}
+	return nil
+}
+
+type AuthRoleRevokePermissionRequest struct {
+	Role     string `protobuf:"bytes,1,opt,name=role,proto3" json:"role,omitempty"`
+	Key      string `protobuf:"bytes,2,opt,name=key,proto3" json:"key,omitempty"`
+	RangeEnd string `protobuf:"bytes,3,opt,name=range_end,json=rangeEnd,proto3" json:"range_end,omitempty"`
+}
+
+func (m *AuthRoleRevokePermissionRequest) Reset()         { *m = AuthRoleRevokePermissionRequest{} }
+func (m *AuthRoleRevokePermissionRequest) String() string { return proto.CompactTextString(m) }
+func (*AuthRoleRevokePermissionRequest) ProtoMessage()    {}
+func (*AuthRoleRevokePermissionRequest) Descriptor() ([]byte, []int) {
+	return fileDescriptorRpc, []int{68}
+}
+
+func (m *AuthRoleRevokePermissionRequest) GetRole() string {
+	if m != nil {
+		return m.Role
+	}
+	return ""
+}
+
+func (m *AuthRoleRevokePermissionRequest) GetKey() string {
+	if m != nil {
+		return m.Key
+	}
+	return ""
+}
+
+func (m *AuthRoleRevokePermissionRequest) GetRangeEnd() string {
+	if m != nil {
+		return m.RangeEnd
+	}
+	return ""
+}
+
+type AuthEnableResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *AuthEnableResponse) Reset()                    { *m = AuthEnableResponse{} }
+func (m *AuthEnableResponse) String() string            { return proto.CompactTextString(m) }
+func (*AuthEnableResponse) ProtoMessage()               {}
+func (*AuthEnableResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{69} }
+
+func (m *AuthEnableResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+type AuthDisableResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *AuthDisableResponse) Reset()                    { *m = AuthDisableResponse{} }
+func (m *AuthDisableResponse) String() string            { return proto.CompactTextString(m) }
+func (*AuthDisableResponse) ProtoMessage()               {}
+func (*AuthDisableResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{70} }
+
+func (m *AuthDisableResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+type AuthenticateResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	// token is an authorized token that can be used in succeeding RPCs
+	Token string `protobuf:"bytes,2,opt,name=token,proto3" json:"token,omitempty"`
+}
+
+func (m *AuthenticateResponse) Reset()                    { *m = AuthenticateResponse{} }
+func (m *AuthenticateResponse) String() string            { return proto.CompactTextString(m) }
+func (*AuthenticateResponse) ProtoMessage()               {}
+func (*AuthenticateResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{71} }
+
+func (m *AuthenticateResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *AuthenticateResponse) GetToken() string {
+	if m != nil {
+		return m.Token
+	}
+	return ""
+}
+
+type AuthUserAddResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *AuthUserAddResponse) Reset()                    { *m = AuthUserAddResponse{} }
+func (m *AuthUserAddResponse) String() string            { return proto.CompactTextString(m) }
+func (*AuthUserAddResponse) ProtoMessage()               {}
+func (*AuthUserAddResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{72} }
+
+func (m *AuthUserAddResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+type AuthUserGetResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	Roles  []string        `protobuf:"bytes,2,rep,name=roles" json:"roles,omitempty"`
+}
+
+func (m *AuthUserGetResponse) Reset()                    { *m = AuthUserGetResponse{} }
+func (m *AuthUserGetResponse) String() string            { return proto.CompactTextString(m) }
+func (*AuthUserGetResponse) ProtoMessage()               {}
+func (*AuthUserGetResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{73} }
+
+func (m *AuthUserGetResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *AuthUserGetResponse) GetRoles() []string {
+	if m != nil {
+		return m.Roles
+	}
+	return nil
+}
+
+type AuthUserDeleteResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *AuthUserDeleteResponse) Reset()                    { *m = AuthUserDeleteResponse{} }
+func (m *AuthUserDeleteResponse) String() string            { return proto.CompactTextString(m) }
+func (*AuthUserDeleteResponse) ProtoMessage()               {}
+func (*AuthUserDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{74} }
+
+func (m *AuthUserDeleteResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+type AuthUserChangePasswordResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *AuthUserChangePasswordResponse) Reset()         { *m = AuthUserChangePasswordResponse{} }
+func (m *AuthUserChangePasswordResponse) String() string { return proto.CompactTextString(m) }
+func (*AuthUserChangePasswordResponse) ProtoMessage()    {}
+func (*AuthUserChangePasswordResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptorRpc, []int{75}
+}
+
+func (m *AuthUserChangePasswordResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+type AuthUserGrantRoleResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *AuthUserGrantRoleResponse) Reset()                    { *m = AuthUserGrantRoleResponse{} }
+func (m *AuthUserGrantRoleResponse) String() string            { return proto.CompactTextString(m) }
+func (*AuthUserGrantRoleResponse) ProtoMessage()               {}
+func (*AuthUserGrantRoleResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{76} }
+
+func (m *AuthUserGrantRoleResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+type AuthUserRevokeRoleResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *AuthUserRevokeRoleResponse) Reset()                    { *m = AuthUserRevokeRoleResponse{} }
+func (m *AuthUserRevokeRoleResponse) String() string            { return proto.CompactTextString(m) }
+func (*AuthUserRevokeRoleResponse) ProtoMessage()               {}
+func (*AuthUserRevokeRoleResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{77} }
+
+func (m *AuthUserRevokeRoleResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+type AuthRoleAddResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *AuthRoleAddResponse) Reset()                    { *m = AuthRoleAddResponse{} }
+func (m *AuthRoleAddResponse) String() string            { return proto.CompactTextString(m) }
+func (*AuthRoleAddResponse) ProtoMessage()               {}
+func (*AuthRoleAddResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{78} }
+
+func (m *AuthRoleAddResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+type AuthRoleGetResponse struct {
+	Header *ResponseHeader      `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	Perm   []*authpb.Permission `protobuf:"bytes,2,rep,name=perm" json:"perm,omitempty"`
+}
+
+func (m *AuthRoleGetResponse) Reset()                    { *m = AuthRoleGetResponse{} }
+func (m *AuthRoleGetResponse) String() string            { return proto.CompactTextString(m) }
+func (*AuthRoleGetResponse) ProtoMessage()               {}
+func (*AuthRoleGetResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{79} }
+
+func (m *AuthRoleGetResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *AuthRoleGetResponse) GetPerm() []*authpb.Permission {
+	if m != nil {
+		return m.Perm
+	}
+	return nil
+}
+
+type AuthRoleListResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	Roles  []string        `protobuf:"bytes,2,rep,name=roles" json:"roles,omitempty"`
+}
+
+func (m *AuthRoleListResponse) Reset()                    { *m = AuthRoleListResponse{} }
+func (m *AuthRoleListResponse) String() string            { return proto.CompactTextString(m) }
+func (*AuthRoleListResponse) ProtoMessage()               {}
+func (*AuthRoleListResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{80} }
+
+func (m *AuthRoleListResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *AuthRoleListResponse) GetRoles() []string {
+	if m != nil {
+		return m.Roles
+	}
+	return nil
+}
+
+type AuthUserListResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+	Users  []string        `protobuf:"bytes,2,rep,name=users" json:"users,omitempty"`
+}
+
+func (m *AuthUserListResponse) Reset()                    { *m = AuthUserListResponse{} }
+func (m *AuthUserListResponse) String() string            { return proto.CompactTextString(m) }
+func (*AuthUserListResponse) ProtoMessage()               {}
+func (*AuthUserListResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{81} }
+
+func (m *AuthUserListResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func (m *AuthUserListResponse) GetUsers() []string {
+	if m != nil {
+		return m.Users
+	}
+	return nil
+}
+
+type AuthRoleDeleteResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *AuthRoleDeleteResponse) Reset()                    { *m = AuthRoleDeleteResponse{} }
+func (m *AuthRoleDeleteResponse) String() string            { return proto.CompactTextString(m) }
+func (*AuthRoleDeleteResponse) ProtoMessage()               {}
+func (*AuthRoleDeleteResponse) Descriptor() ([]byte, []int) { return fileDescriptorRpc, []int{82} }
+
+func (m *AuthRoleDeleteResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+type AuthRoleGrantPermissionResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *AuthRoleGrantPermissionResponse) Reset()         { *m = AuthRoleGrantPermissionResponse{} }
+func (m *AuthRoleGrantPermissionResponse) String() string { return proto.CompactTextString(m) }
+func (*AuthRoleGrantPermissionResponse) ProtoMessage()    {}
+func (*AuthRoleGrantPermissionResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptorRpc, []int{83}
+}
+
+func (m *AuthRoleGrantPermissionResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+type AuthRoleRevokePermissionResponse struct {
+	Header *ResponseHeader `protobuf:"bytes,1,opt,name=header" json:"header,omitempty"`
+}
+
+func (m *AuthRoleRevokePermissionResponse) Reset()         { *m = AuthRoleRevokePermissionResponse{} }
+func (m *AuthRoleRevokePermissionResponse) String() string { return proto.CompactTextString(m) }
+func (*AuthRoleRevokePermissionResponse) ProtoMessage()    {}
+func (*AuthRoleRevokePermissionResponse) Descriptor() ([]byte, []int) {
+	return fileDescriptorRpc, []int{84}
+}
+
+func (m *AuthRoleRevokePermissionResponse) GetHeader() *ResponseHeader {
+	if m != nil {
+		return m.Header
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*ResponseHeader)(nil), "etcdserverpb.ResponseHeader")
+	proto.RegisterType((*RangeRequest)(nil), "etcdserverpb.RangeRequest")
+	proto.RegisterType((*RangeResponse)(nil), "etcdserverpb.RangeResponse")
+	proto.RegisterType((*PutRequest)(nil), "etcdserverpb.PutRequest")
+	proto.RegisterType((*PutResponse)(nil), "etcdserverpb.PutResponse")
+	proto.RegisterType((*DeleteRangeRequest)(nil), "etcdserverpb.DeleteRangeRequest")
+	proto.RegisterType((*DeleteRangeResponse)(nil), "etcdserverpb.DeleteRangeResponse")
+	proto.RegisterType((*RequestOp)(nil), "etcdserverpb.RequestOp")
+	proto.RegisterType((*ResponseOp)(nil), "etcdserverpb.ResponseOp")
+	proto.RegisterType((*Compare)(nil), "etcdserverpb.Compare")
+	proto.RegisterType((*TxnRequest)(nil), "etcdserverpb.TxnRequest")
+	proto.RegisterType((*TxnResponse)(nil), "etcdserverpb.TxnResponse")
+	proto.RegisterType((*CompactionRequest)(nil), "etcdserverpb.CompactionRequest")
+	proto.RegisterType((*CompactionResponse)(nil), "etcdserverpb.CompactionResponse")
+	proto.RegisterType((*HashRequest)(nil), "etcdserverpb.HashRequest")
+	proto.RegisterType((*HashKVRequest)(nil), "etcdserverpb.HashKVRequest")
+	proto.RegisterType((*HashKVResponse)(nil), "etcdserverpb.HashKVResponse")
+	proto.RegisterType((*HashResponse)(nil), "etcdserverpb.HashResponse")
+	proto.RegisterType((*SnapshotRequest)(nil), "etcdserverpb.SnapshotRequest")
+	proto.RegisterType((*SnapshotResponse)(nil), "etcdserverpb.SnapshotResponse")
+	proto.RegisterType((*WatchRequest)(nil), "etcdserverpb.WatchRequest")
+	proto.RegisterType((*WatchCreateRequest)(nil), "etcdserverpb.WatchCreateRequest")
+	proto.RegisterType((*WatchCancelRequest)(nil), "etcdserverpb.WatchCancelRequest")
+	proto.RegisterType((*WatchResponse)(nil), "etcdserverpb.WatchResponse")
+	proto.RegisterType((*LeaseGrantRequest)(nil), "etcdserverpb.LeaseGrantRequest")
+	proto.RegisterType((*LeaseGrantResponse)(nil), "etcdserverpb.LeaseGrantResponse")
+	proto.RegisterType((*LeaseRevokeRequest)(nil), "etcdserverpb.LeaseRevokeRequest")
+	proto.RegisterType((*LeaseRevokeResponse)(nil), "etcdserverpb.LeaseRevokeResponse")
+	proto.RegisterType((*LeaseKeepAliveRequest)(nil), "etcdserverpb.LeaseKeepAliveRequest")
+	proto.RegisterType((*LeaseKeepAliveResponse)(nil), "etcdserverpb.LeaseKeepAliveResponse")
+	proto.RegisterType((*LeaseTimeToLiveRequest)(nil), "etcdserverpb.LeaseTimeToLiveRequest")
+	proto.RegisterType((*LeaseTimeToLiveResponse)(nil), "etcdserverpb.LeaseTimeToLiveResponse")
+	proto.RegisterType((*LeaseLeasesRequest)(nil), "etcdserverpb.LeaseLeasesRequest")
+	proto.RegisterType((*LeaseStatus)(nil), "etcdserverpb.LeaseStatus")
+	proto.RegisterType((*LeaseLeasesResponse)(nil), "etcdserverpb.LeaseLeasesResponse")
+	proto.RegisterType((*Member)(nil), "etcdserverpb.Member")
+	proto.RegisterType((*MemberAddRequest)(nil), "etcdserverpb.MemberAddRequest")
+	proto.RegisterType((*MemberAddResponse)(nil), "etcdserverpb.MemberAddResponse")
+	proto.RegisterType((*MemberRemoveRequest)(nil), "etcdserverpb.MemberRemoveRequest")
+	proto.RegisterType((*MemberRemoveResponse)(nil), "etcdserverpb.MemberRemoveResponse")
+	proto.RegisterType((*MemberUpdateRequest)(nil), "etcdserverpb.MemberUpdateRequest")
+	proto.RegisterType((*MemberUpdateResponse)(nil), "etcdserverpb.MemberUpdateResponse")
+	proto.RegisterType((*MemberListRequest)(nil), "etcdserverpb.MemberListRequest")
+	proto.RegisterType((*MemberListResponse)(nil), "etcdserverpb.MemberListResponse")
+	proto.RegisterType((*DefragmentRequest)(nil), "etcdserverpb.DefragmentRequest")
+	proto.RegisterType((*DefragmentResponse)(nil), "etcdserverpb.DefragmentResponse")
+	proto.RegisterType((*MoveLeaderRequest)(nil), "etcdserverpb.MoveLeaderRequest")
+	proto.RegisterType((*MoveLeaderResponse)(nil), "etcdserverpb.MoveLeaderResponse")
+	proto.RegisterType((*AlarmRequest)(nil), "etcdserverpb.AlarmRequest")
+	proto.RegisterType((*AlarmMember)(nil), "etcdserverpb.AlarmMember")
+	proto.RegisterType((*AlarmResponse)(nil), "etcdserverpb.AlarmResponse")
+	proto.RegisterType((*StatusRequest)(nil), "etcdserverpb.StatusRequest")
+	proto.RegisterType((*StatusResponse)(nil), "etcdserverpb.StatusResponse")
+	proto.RegisterType((*AuthEnableRequest)(nil), "etcdserverpb.AuthEnableRequest")
+	proto.RegisterType((*AuthDisableRequest)(nil), "etcdserverpb.AuthDisableRequest")
+	proto.RegisterType((*AuthenticateRequest)(nil), "etcdserverpb.AuthenticateRequest")
+	proto.RegisterType((*AuthUserAddRequest)(nil), "etcdserverpb.AuthUserAddRequest")
+	proto.RegisterType((*AuthUserGetRequest)(nil), "etcdserverpb.AuthUserGetRequest")
+	proto.RegisterType((*AuthUserDeleteRequest)(nil), "etcdserverpb.AuthUserDeleteRequest")
+	proto.RegisterType((*AuthUserChangePasswordRequest)(nil), "etcdserverpb.AuthUserChangePasswordRequest")
+	proto.RegisterType((*AuthUserGrantRoleRequest)(nil), "etcdserverpb.AuthUserGrantRoleRequest")
+	proto.RegisterType((*AuthUserRevokeRoleRequest)(nil), "etcdserverpb.AuthUserRevokeRoleRequest")
+	proto.RegisterType((*AuthRoleAddRequest)(nil), "etcdserverpb.AuthRoleAddRequest")
+	proto.RegisterType((*AuthRoleGetRequest)(nil), "etcdserverpb.AuthRoleGetRequest")
+	proto.RegisterType((*AuthUserListRequest)(nil), "etcdserverpb.AuthUserListRequest")
+	proto.RegisterType((*AuthRoleListRequest)(nil), "etcdserverpb.AuthRoleListRequest")
+	proto.RegisterType((*AuthRoleDeleteRequest)(nil), "etcdserverpb.AuthRoleDeleteRequest")
+	proto.RegisterType((*AuthRoleGrantPermissionRequest)(nil), "etcdserverpb.AuthRoleGrantPermissionRequest")
+	proto.RegisterType((*AuthRoleRevokePermissionRequest)(nil), "etcdserverpb.AuthRoleRevokePermissionRequest")
+	proto.RegisterType((*AuthEnableResponse)(nil), "etcdserverpb.AuthEnableResponse")
+	proto.RegisterType((*AuthDisableResponse)(nil), "etcdserverpb.AuthDisableResponse")
+	proto.RegisterType((*AuthenticateResponse)(nil), "etcdserverpb.AuthenticateResponse")
+	proto.RegisterType((*AuthUserAddResponse)(nil), "etcdserverpb.AuthUserAddResponse")
+	proto.RegisterType((*AuthUserGetResponse)(nil), "etcdserverpb.AuthUserGetResponse")
+	proto.RegisterType((*AuthUserDeleteResponse)(nil), "etcdserverpb.AuthUserDeleteResponse")
+	proto.RegisterType((*AuthUserChangePasswordResponse)(nil), "etcdserverpb.AuthUserChangePasswordResponse")
+	proto.RegisterType((*AuthUserGrantRoleResponse)(nil), "etcdserverpb.AuthUserGrantRoleResponse")
+	proto.RegisterType((*AuthUserRevokeRoleResponse)(nil), "etcdserverpb.AuthUserRevokeRoleResponse")
+	proto.RegisterType((*AuthRoleAddResponse)(nil), "etcdserverpb.AuthRoleAddResponse")
+	proto.RegisterType((*AuthRoleGetResponse)(nil), "etcdserverpb.AuthRoleGetResponse")
+	proto.RegisterType((*AuthRoleListResponse)(nil), "etcdserverpb.AuthRoleListResponse")
+	proto.RegisterType((*AuthUserListResponse)(nil), "etcdserverpb.AuthUserListResponse")
+	proto.RegisterType((*AuthRoleDeleteResponse)(nil), "etcdserverpb.AuthRoleDeleteResponse")
+	proto.RegisterType((*AuthRoleGrantPermissionResponse)(nil), "etcdserverpb.AuthRoleGrantPermissionResponse")
+	proto.RegisterType((*AuthRoleRevokePermissionResponse)(nil), "etcdserverpb.AuthRoleRevokePermissionResponse")
+	proto.RegisterEnum("etcdserverpb.AlarmType", AlarmType_name, AlarmType_value)
+	proto.RegisterEnum("etcdserverpb.RangeRequest_SortOrder", RangeRequest_SortOrder_name, RangeRequest_SortOrder_value)
+	proto.RegisterEnum("etcdserverpb.RangeRequest_SortTarget", RangeRequest_SortTarget_name, RangeRequest_SortTarget_value)
+	proto.RegisterEnum("etcdserverpb.Compare_CompareResult", Compare_CompareResult_name, Compare_CompareResult_value)
+	proto.RegisterEnum("etcdserverpb.Compare_CompareTarget", Compare_CompareTarget_name, Compare_CompareTarget_value)
+	proto.RegisterEnum("etcdserverpb.WatchCreateRequest_FilterType", WatchCreateRequest_FilterType_name, WatchCreateRequest_FilterType_value)
+	proto.RegisterEnum("etcdserverpb.AlarmRequest_AlarmAction", AlarmRequest_AlarmAction_name, AlarmRequest_AlarmAction_value)
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for KV service
+
+type KVClient interface {
+	// Range gets the keys in the range from the key-value store.
+	Range(ctx context.Context, in *RangeRequest, opts ...grpc.CallOption) (*RangeResponse, error)
+	// Put puts the given key into the key-value store.
+	// A put request increments the revision of the key-value store
+	// and generates one event in the event history.
+	Put(ctx context.Context, in *PutRequest, opts ...grpc.CallOption) (*PutResponse, error)
+	// DeleteRange deletes the given range from the key-value store.
+	// A delete request increments the revision of the key-value store
+	// and generates a delete event in the event history for every deleted key.
+	DeleteRange(ctx context.Context, in *DeleteRangeRequest, opts ...grpc.CallOption) (*DeleteRangeResponse, error)
+	// Txn processes multiple requests in a single transaction.
+	// A txn request increments the revision of the key-value store
+	// and generates events with the same revision for every completed request.
+	// It is not allowed to modify the same key several times within one txn.
+	Txn(ctx context.Context, in *TxnRequest, opts ...grpc.CallOption) (*TxnResponse, error)
+	// Compact compacts the event history in the etcd key-value store. The key-value
+	// store should be periodically compacted or the event history will continue to grow
+	// indefinitely.
+	Compact(ctx context.Context, in *CompactionRequest, opts ...grpc.CallOption) (*CompactionResponse, error)
+}
+
+type kVClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewKVClient(cc *grpc.ClientConn) KVClient {
+	return &kVClient{cc}
+}
+
+func (c *kVClient) Range(ctx context.Context, in *RangeRequest, opts ...grpc.CallOption) (*RangeResponse, error) {
+	out := new(RangeResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.KV/Range", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *kVClient) Put(ctx context.Context, in *PutRequest, opts ...grpc.CallOption) (*PutResponse, error) {
+	out := new(PutResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.KV/Put", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *kVClient) DeleteRange(ctx context.Context, in *DeleteRangeRequest, opts ...grpc.CallOption) (*DeleteRangeResponse, error) {
+	out := new(DeleteRangeResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.KV/DeleteRange", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *kVClient) Txn(ctx context.Context, in *TxnRequest, opts ...grpc.CallOption) (*TxnResponse, error) {
+	out := new(TxnResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.KV/Txn", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *kVClient) Compact(ctx context.Context, in *CompactionRequest, opts ...grpc.CallOption) (*CompactionResponse, error) {
+	out := new(CompactionResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.KV/Compact", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for KV service
+
+type KVServer interface {
+	// Range gets the keys in the range from the key-value store.
+	Range(context.Context, *RangeRequest) (*RangeResponse, error)
+	// Put puts the given key into the key-value store.
+	// A put request increments the revision of the key-value store
+	// and generates one event in the event history.
+	Put(context.Context, *PutRequest) (*PutResponse, error)
+	// DeleteRange deletes the given range from the key-value store.
+	// A delete request increments the revision of the key-value store
+	// and generates a delete event in the event history for every deleted key.
+	DeleteRange(context.Context, *DeleteRangeRequest) (*DeleteRangeResponse, error)
+	// Txn processes multiple requests in a single transaction.
+	// A txn request increments the revision of the key-value store
+	// and generates events with the same revision for every completed request.
+	// It is not allowed to modify the same key several times within one txn.
+	Txn(context.Context, *TxnRequest) (*TxnResponse, error)
+	// Compact compacts the event history in the etcd key-value store. The key-value
+	// store should be periodically compacted or the event history will continue to grow
+	// indefinitely.
+	Compact(context.Context, *CompactionRequest) (*CompactionResponse, error)
+}
+
+func RegisterKVServer(s *grpc.Server, srv KVServer) {
+	s.RegisterService(&_KV_serviceDesc, srv)
+}
+
+func _KV_Range_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(RangeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(KVServer).Range(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.KV/Range",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(KVServer).Range(ctx, req.(*RangeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _KV_Put_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(PutRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(KVServer).Put(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.KV/Put",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(KVServer).Put(ctx, req.(*PutRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _KV_DeleteRange_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DeleteRangeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(KVServer).DeleteRange(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.KV/DeleteRange",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(KVServer).DeleteRange(ctx, req.(*DeleteRangeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _KV_Txn_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(TxnRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(KVServer).Txn(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.KV/Txn",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(KVServer).Txn(ctx, req.(*TxnRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _KV_Compact_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(CompactionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(KVServer).Compact(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.KV/Compact",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(KVServer).Compact(ctx, req.(*CompactionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _KV_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "etcdserverpb.KV",
+	HandlerType: (*KVServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Range",
+			Handler:    _KV_Range_Handler,
+		},
+		{
+			MethodName: "Put",
+			Handler:    _KV_Put_Handler,
+		},
+		{
+			MethodName: "DeleteRange",
+			Handler:    _KV_DeleteRange_Handler,
+		},
+		{
+			MethodName: "Txn",
+			Handler:    _KV_Txn_Handler,
+		},
+		{
+			MethodName: "Compact",
+			Handler:    _KV_Compact_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "rpc.proto",
+}
+
+// Client API for Watch service
+
+type WatchClient interface {
+	// Watch watches for events happening or that have happened. Both input and output
+	// are streams; the input stream is for creating and canceling watchers and the output
+	// stream sends events. One watch RPC can watch on multiple key ranges, streaming events
+	// for several watches at once. The entire event history can be watched starting from the
+	// last compaction revision.
+	Watch(ctx context.Context, opts ...grpc.CallOption) (Watch_WatchClient, error)
+}
+
+type watchClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewWatchClient(cc *grpc.ClientConn) WatchClient {
+	return &watchClient{cc}
+}
+
+func (c *watchClient) Watch(ctx context.Context, opts ...grpc.CallOption) (Watch_WatchClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_Watch_serviceDesc.Streams[0], c.cc, "/etcdserverpb.Watch/Watch", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &watchWatchClient{stream}
+	return x, nil
+}
+
+type Watch_WatchClient interface {
+	Send(*WatchRequest) error
+	Recv() (*WatchResponse, error)
+	grpc.ClientStream
+}
+
+type watchWatchClient struct {
+	grpc.ClientStream
+}
+
+func (x *watchWatchClient) Send(m *WatchRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *watchWatchClient) Recv() (*WatchResponse, error) {
+	m := new(WatchResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+// Server API for Watch service
+
+type WatchServer interface {
+	// Watch watches for events happening or that have happened. Both input and output
+	// are streams; the input stream is for creating and canceling watchers and the output
+	// stream sends events. One watch RPC can watch on multiple key ranges, streaming events
+	// for several watches at once. The entire event history can be watched starting from the
+	// last compaction revision.
+	Watch(Watch_WatchServer) error
+}
+
+func RegisterWatchServer(s *grpc.Server, srv WatchServer) {
+	s.RegisterService(&_Watch_serviceDesc, srv)
+}
+
+func _Watch_Watch_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(WatchServer).Watch(&watchWatchServer{stream})
+}
+
+type Watch_WatchServer interface {
+	Send(*WatchResponse) error
+	Recv() (*WatchRequest, error)
+	grpc.ServerStream
+}
+
+type watchWatchServer struct {
+	grpc.ServerStream
+}
+
+func (x *watchWatchServer) Send(m *WatchResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *watchWatchServer) Recv() (*WatchRequest, error) {
+	m := new(WatchRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+var _Watch_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "etcdserverpb.Watch",
+	HandlerType: (*WatchServer)(nil),
+	Methods:     []grpc.MethodDesc{},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "Watch",
+			Handler:       _Watch_Watch_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+	},
+	Metadata: "rpc.proto",
+}
+
+// Client API for Lease service
+
+type LeaseClient interface {
+	// LeaseGrant creates a lease which expires if the server does not receive a keepAlive
+	// within a given time to live period. All keys attached to the lease will be expired and
+	// deleted if the lease expires. Each expired key generates a delete event in the event history.
+	LeaseGrant(ctx context.Context, in *LeaseGrantRequest, opts ...grpc.CallOption) (*LeaseGrantResponse, error)
+	// LeaseRevoke revokes a lease. All keys attached to the lease will expire and be deleted.
+	LeaseRevoke(ctx context.Context, in *LeaseRevokeRequest, opts ...grpc.CallOption) (*LeaseRevokeResponse, error)
+	// LeaseKeepAlive keeps the lease alive by streaming keep alive requests from the client
+	// to the server and streaming keep alive responses from the server to the client.
+	LeaseKeepAlive(ctx context.Context, opts ...grpc.CallOption) (Lease_LeaseKeepAliveClient, error)
+	// LeaseTimeToLive retrieves lease information.
+	LeaseTimeToLive(ctx context.Context, in *LeaseTimeToLiveRequest, opts ...grpc.CallOption) (*LeaseTimeToLiveResponse, error)
+	// LeaseLeases lists all existing leases.
+	LeaseLeases(ctx context.Context, in *LeaseLeasesRequest, opts ...grpc.CallOption) (*LeaseLeasesResponse, error)
+}
+
+type leaseClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewLeaseClient(cc *grpc.ClientConn) LeaseClient {
+	return &leaseClient{cc}
+}
+
+func (c *leaseClient) LeaseGrant(ctx context.Context, in *LeaseGrantRequest, opts ...grpc.CallOption) (*LeaseGrantResponse, error) {
+	out := new(LeaseGrantResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Lease/LeaseGrant", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *leaseClient) LeaseRevoke(ctx context.Context, in *LeaseRevokeRequest, opts ...grpc.CallOption) (*LeaseRevokeResponse, error) {
+	out := new(LeaseRevokeResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Lease/LeaseRevoke", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *leaseClient) LeaseKeepAlive(ctx context.Context, opts ...grpc.CallOption) (Lease_LeaseKeepAliveClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_Lease_serviceDesc.Streams[0], c.cc, "/etcdserverpb.Lease/LeaseKeepAlive", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &leaseLeaseKeepAliveClient{stream}
+	return x, nil
+}
+
+type Lease_LeaseKeepAliveClient interface {
+	Send(*LeaseKeepAliveRequest) error
+	Recv() (*LeaseKeepAliveResponse, error)
+	grpc.ClientStream
+}
+
+type leaseLeaseKeepAliveClient struct {
+	grpc.ClientStream
+}
+
+func (x *leaseLeaseKeepAliveClient) Send(m *LeaseKeepAliveRequest) error {
+	return x.ClientStream.SendMsg(m)
+}
+
+func (x *leaseLeaseKeepAliveClient) Recv() (*LeaseKeepAliveResponse, error) {
+	m := new(LeaseKeepAliveResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *leaseClient) LeaseTimeToLive(ctx context.Context, in *LeaseTimeToLiveRequest, opts ...grpc.CallOption) (*LeaseTimeToLiveResponse, error) {
+	out := new(LeaseTimeToLiveResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Lease/LeaseTimeToLive", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *leaseClient) LeaseLeases(ctx context.Context, in *LeaseLeasesRequest, opts ...grpc.CallOption) (*LeaseLeasesResponse, error) {
+	out := new(LeaseLeasesResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Lease/LeaseLeases", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Lease service
+
+type LeaseServer interface {
+	// LeaseGrant creates a lease which expires if the server does not receive a keepAlive
+	// within a given time to live period. All keys attached to the lease will be expired and
+	// deleted if the lease expires. Each expired key generates a delete event in the event history.
+	LeaseGrant(context.Context, *LeaseGrantRequest) (*LeaseGrantResponse, error)
+	// LeaseRevoke revokes a lease. All keys attached to the lease will expire and be deleted.
+	LeaseRevoke(context.Context, *LeaseRevokeRequest) (*LeaseRevokeResponse, error)
+	// LeaseKeepAlive keeps the lease alive by streaming keep alive requests from the client
+	// to the server and streaming keep alive responses from the server to the client.
+	LeaseKeepAlive(Lease_LeaseKeepAliveServer) error
+	// LeaseTimeToLive retrieves lease information.
+	LeaseTimeToLive(context.Context, *LeaseTimeToLiveRequest) (*LeaseTimeToLiveResponse, error)
+	// LeaseLeases lists all existing leases.
+	LeaseLeases(context.Context, *LeaseLeasesRequest) (*LeaseLeasesResponse, error)
+}
+
+func RegisterLeaseServer(s *grpc.Server, srv LeaseServer) {
+	s.RegisterService(&_Lease_serviceDesc, srv)
+}
+
+func _Lease_LeaseGrant_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(LeaseGrantRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LeaseServer).LeaseGrant(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Lease/LeaseGrant",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LeaseServer).LeaseGrant(ctx, req.(*LeaseGrantRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Lease_LeaseRevoke_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(LeaseRevokeRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LeaseServer).LeaseRevoke(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Lease/LeaseRevoke",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LeaseServer).LeaseRevoke(ctx, req.(*LeaseRevokeRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Lease_LeaseKeepAlive_Handler(srv interface{}, stream grpc.ServerStream) error {
+	return srv.(LeaseServer).LeaseKeepAlive(&leaseLeaseKeepAliveServer{stream})
+}
+
+type Lease_LeaseKeepAliveServer interface {
+	Send(*LeaseKeepAliveResponse) error
+	Recv() (*LeaseKeepAliveRequest, error)
+	grpc.ServerStream
+}
+
+type leaseLeaseKeepAliveServer struct {
+	grpc.ServerStream
+}
+
+func (x *leaseLeaseKeepAliveServer) Send(m *LeaseKeepAliveResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func (x *leaseLeaseKeepAliveServer) Recv() (*LeaseKeepAliveRequest, error) {
+	m := new(LeaseKeepAliveRequest)
+	if err := x.ServerStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func _Lease_LeaseTimeToLive_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(LeaseTimeToLiveRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LeaseServer).LeaseTimeToLive(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Lease/LeaseTimeToLive",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LeaseServer).LeaseTimeToLive(ctx, req.(*LeaseTimeToLiveRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Lease_LeaseLeases_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(LeaseLeasesRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(LeaseServer).LeaseLeases(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Lease/LeaseLeases",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(LeaseServer).LeaseLeases(ctx, req.(*LeaseLeasesRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Lease_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "etcdserverpb.Lease",
+	HandlerType: (*LeaseServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "LeaseGrant",
+			Handler:    _Lease_LeaseGrant_Handler,
+		},
+		{
+			MethodName: "LeaseRevoke",
+			Handler:    _Lease_LeaseRevoke_Handler,
+		},
+		{
+			MethodName: "LeaseTimeToLive",
+			Handler:    _Lease_LeaseTimeToLive_Handler,
+		},
+		{
+			MethodName: "LeaseLeases",
+			Handler:    _Lease_LeaseLeases_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "LeaseKeepAlive",
+			Handler:       _Lease_LeaseKeepAlive_Handler,
+			ServerStreams: true,
+			ClientStreams: true,
+		},
+	},
+	Metadata: "rpc.proto",
+}
+
+// Client API for Cluster service
+
+type ClusterClient interface {
+	// MemberAdd adds a member into the cluster.
+	MemberAdd(ctx context.Context, in *MemberAddRequest, opts ...grpc.CallOption) (*MemberAddResponse, error)
+	// MemberRemove removes an existing member from the cluster.
+	MemberRemove(ctx context.Context, in *MemberRemoveRequest, opts ...grpc.CallOption) (*MemberRemoveResponse, error)
+	// MemberUpdate updates the member configuration.
+	MemberUpdate(ctx context.Context, in *MemberUpdateRequest, opts ...grpc.CallOption) (*MemberUpdateResponse, error)
+	// MemberList lists all the members in the cluster.
+	MemberList(ctx context.Context, in *MemberListRequest, opts ...grpc.CallOption) (*MemberListResponse, error)
+}
+
+type clusterClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewClusterClient(cc *grpc.ClientConn) ClusterClient {
+	return &clusterClient{cc}
+}
+
+func (c *clusterClient) MemberAdd(ctx context.Context, in *MemberAddRequest, opts ...grpc.CallOption) (*MemberAddResponse, error) {
+	out := new(MemberAddResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Cluster/MemberAdd", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *clusterClient) MemberRemove(ctx context.Context, in *MemberRemoveRequest, opts ...grpc.CallOption) (*MemberRemoveResponse, error) {
+	out := new(MemberRemoveResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Cluster/MemberRemove", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *clusterClient) MemberUpdate(ctx context.Context, in *MemberUpdateRequest, opts ...grpc.CallOption) (*MemberUpdateResponse, error) {
+	out := new(MemberUpdateResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Cluster/MemberUpdate", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *clusterClient) MemberList(ctx context.Context, in *MemberListRequest, opts ...grpc.CallOption) (*MemberListResponse, error) {
+	out := new(MemberListResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Cluster/MemberList", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Cluster service
+
+type ClusterServer interface {
+	// MemberAdd adds a member into the cluster.
+	MemberAdd(context.Context, *MemberAddRequest) (*MemberAddResponse, error)
+	// MemberRemove removes an existing member from the cluster.
+	MemberRemove(context.Context, *MemberRemoveRequest) (*MemberRemoveResponse, error)
+	// MemberUpdate updates the member configuration.
+	MemberUpdate(context.Context, *MemberUpdateRequest) (*MemberUpdateResponse, error)
+	// MemberList lists all the members in the cluster.
+	MemberList(context.Context, *MemberListRequest) (*MemberListResponse, error)
+}
+
+func RegisterClusterServer(s *grpc.Server, srv ClusterServer) {
+	s.RegisterService(&_Cluster_serviceDesc, srv)
+}
+
+func _Cluster_MemberAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MemberAddRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ClusterServer).MemberAdd(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Cluster/MemberAdd",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ClusterServer).MemberAdd(ctx, req.(*MemberAddRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Cluster_MemberRemove_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MemberRemoveRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ClusterServer).MemberRemove(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Cluster/MemberRemove",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ClusterServer).MemberRemove(ctx, req.(*MemberRemoveRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Cluster_MemberUpdate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MemberUpdateRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ClusterServer).MemberUpdate(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Cluster/MemberUpdate",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ClusterServer).MemberUpdate(ctx, req.(*MemberUpdateRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Cluster_MemberList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MemberListRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(ClusterServer).MemberList(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Cluster/MemberList",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(ClusterServer).MemberList(ctx, req.(*MemberListRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Cluster_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "etcdserverpb.Cluster",
+	HandlerType: (*ClusterServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "MemberAdd",
+			Handler:    _Cluster_MemberAdd_Handler,
+		},
+		{
+			MethodName: "MemberRemove",
+			Handler:    _Cluster_MemberRemove_Handler,
+		},
+		{
+			MethodName: "MemberUpdate",
+			Handler:    _Cluster_MemberUpdate_Handler,
+		},
+		{
+			MethodName: "MemberList",
+			Handler:    _Cluster_MemberList_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "rpc.proto",
+}
+
+// Client API for Maintenance service
+
+type MaintenanceClient interface {
+	// Alarm activates, deactivates, and queries alarms regarding cluster health.
+	Alarm(ctx context.Context, in *AlarmRequest, opts ...grpc.CallOption) (*AlarmResponse, error)
+	// Status gets the status of the member.
+	Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error)
+	// Defragment defragments a member's backend database to recover storage space.
+	Defragment(ctx context.Context, in *DefragmentRequest, opts ...grpc.CallOption) (*DefragmentResponse, error)
+	// Hash computes the hash of the KV's backend.
+	// This is designed for testing; do not use this in production when there
+	// are ongoing transactions.
+	Hash(ctx context.Context, in *HashRequest, opts ...grpc.CallOption) (*HashResponse, error)
+	// HashKV computes the hash of all MVCC keys up to a given revision.
+	HashKV(ctx context.Context, in *HashKVRequest, opts ...grpc.CallOption) (*HashKVResponse, error)
+	// Snapshot sends a snapshot of the entire backend from a member over a stream to a client.
+	Snapshot(ctx context.Context, in *SnapshotRequest, opts ...grpc.CallOption) (Maintenance_SnapshotClient, error)
+	// MoveLeader requests current leader node to transfer its leadership to transferee.
+	MoveLeader(ctx context.Context, in *MoveLeaderRequest, opts ...grpc.CallOption) (*MoveLeaderResponse, error)
+}
+
+type maintenanceClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewMaintenanceClient(cc *grpc.ClientConn) MaintenanceClient {
+	return &maintenanceClient{cc}
+}
+
+func (c *maintenanceClient) Alarm(ctx context.Context, in *AlarmRequest, opts ...grpc.CallOption) (*AlarmResponse, error) {
+	out := new(AlarmResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Maintenance/Alarm", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *maintenanceClient) Status(ctx context.Context, in *StatusRequest, opts ...grpc.CallOption) (*StatusResponse, error) {
+	out := new(StatusResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Maintenance/Status", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *maintenanceClient) Defragment(ctx context.Context, in *DefragmentRequest, opts ...grpc.CallOption) (*DefragmentResponse, error) {
+	out := new(DefragmentResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Maintenance/Defragment", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *maintenanceClient) Hash(ctx context.Context, in *HashRequest, opts ...grpc.CallOption) (*HashResponse, error) {
+	out := new(HashResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Maintenance/Hash", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *maintenanceClient) HashKV(ctx context.Context, in *HashKVRequest, opts ...grpc.CallOption) (*HashKVResponse, error) {
+	out := new(HashKVResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Maintenance/HashKV", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *maintenanceClient) Snapshot(ctx context.Context, in *SnapshotRequest, opts ...grpc.CallOption) (Maintenance_SnapshotClient, error) {
+	stream, err := grpc.NewClientStream(ctx, &_Maintenance_serviceDesc.Streams[0], c.cc, "/etcdserverpb.Maintenance/Snapshot", opts...)
+	if err != nil {
+		return nil, err
+	}
+	x := &maintenanceSnapshotClient{stream}
+	if err := x.ClientStream.SendMsg(in); err != nil {
+		return nil, err
+	}
+	if err := x.ClientStream.CloseSend(); err != nil {
+		return nil, err
+	}
+	return x, nil
+}
+
+type Maintenance_SnapshotClient interface {
+	Recv() (*SnapshotResponse, error)
+	grpc.ClientStream
+}
+
+type maintenanceSnapshotClient struct {
+	grpc.ClientStream
+}
+
+func (x *maintenanceSnapshotClient) Recv() (*SnapshotResponse, error) {
+	m := new(SnapshotResponse)
+	if err := x.ClientStream.RecvMsg(m); err != nil {
+		return nil, err
+	}
+	return m, nil
+}
+
+func (c *maintenanceClient) MoveLeader(ctx context.Context, in *MoveLeaderRequest, opts ...grpc.CallOption) (*MoveLeaderResponse, error) {
+	out := new(MoveLeaderResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Maintenance/MoveLeader", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Maintenance service
+
+type MaintenanceServer interface {
+	// Alarm activates, deactivates, and queries alarms regarding cluster health.
+	Alarm(context.Context, *AlarmRequest) (*AlarmResponse, error)
+	// Status gets the status of the member.
+	Status(context.Context, *StatusRequest) (*StatusResponse, error)
+	// Defragment defragments a member's backend database to recover storage space.
+	Defragment(context.Context, *DefragmentRequest) (*DefragmentResponse, error)
+	// Hash computes the hash of the KV's backend.
+	// This is designed for testing; do not use this in production when there
+	// are ongoing transactions.
+	Hash(context.Context, *HashRequest) (*HashResponse, error)
+	// HashKV computes the hash of all MVCC keys up to a given revision.
+	HashKV(context.Context, *HashKVRequest) (*HashKVResponse, error)
+	// Snapshot sends a snapshot of the entire backend from a member over a stream to a client.
+	Snapshot(*SnapshotRequest, Maintenance_SnapshotServer) error
+	// MoveLeader requests current leader node to transfer its leadership to transferee.
+	MoveLeader(context.Context, *MoveLeaderRequest) (*MoveLeaderResponse, error)
+}
+
+func RegisterMaintenanceServer(s *grpc.Server, srv MaintenanceServer) {
+	s.RegisterService(&_Maintenance_serviceDesc, srv)
+}
+
+func _Maintenance_Alarm_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AlarmRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MaintenanceServer).Alarm(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Maintenance/Alarm",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MaintenanceServer).Alarm(ctx, req.(*AlarmRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Maintenance_Status_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(StatusRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MaintenanceServer).Status(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Maintenance/Status",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MaintenanceServer).Status(ctx, req.(*StatusRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Maintenance_Defragment_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(DefragmentRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MaintenanceServer).Defragment(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Maintenance/Defragment",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MaintenanceServer).Defragment(ctx, req.(*DefragmentRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Maintenance_Hash_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(HashRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MaintenanceServer).Hash(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Maintenance/Hash",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MaintenanceServer).Hash(ctx, req.(*HashRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Maintenance_HashKV_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(HashKVRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MaintenanceServer).HashKV(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Maintenance/HashKV",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MaintenanceServer).HashKV(ctx, req.(*HashKVRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Maintenance_Snapshot_Handler(srv interface{}, stream grpc.ServerStream) error {
+	m := new(SnapshotRequest)
+	if err := stream.RecvMsg(m); err != nil {
+		return err
+	}
+	return srv.(MaintenanceServer).Snapshot(m, &maintenanceSnapshotServer{stream})
+}
+
+type Maintenance_SnapshotServer interface {
+	Send(*SnapshotResponse) error
+	grpc.ServerStream
+}
+
+type maintenanceSnapshotServer struct {
+	grpc.ServerStream
+}
+
+func (x *maintenanceSnapshotServer) Send(m *SnapshotResponse) error {
+	return x.ServerStream.SendMsg(m)
+}
+
+func _Maintenance_MoveLeader_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(MoveLeaderRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(MaintenanceServer).MoveLeader(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Maintenance/MoveLeader",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(MaintenanceServer).MoveLeader(ctx, req.(*MoveLeaderRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Maintenance_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "etcdserverpb.Maintenance",
+	HandlerType: (*MaintenanceServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Alarm",
+			Handler:    _Maintenance_Alarm_Handler,
+		},
+		{
+			MethodName: "Status",
+			Handler:    _Maintenance_Status_Handler,
+		},
+		{
+			MethodName: "Defragment",
+			Handler:    _Maintenance_Defragment_Handler,
+		},
+		{
+			MethodName: "Hash",
+			Handler:    _Maintenance_Hash_Handler,
+		},
+		{
+			MethodName: "HashKV",
+			Handler:    _Maintenance_HashKV_Handler,
+		},
+		{
+			MethodName: "MoveLeader",
+			Handler:    _Maintenance_MoveLeader_Handler,
+		},
+	},
+	Streams: []grpc.StreamDesc{
+		{
+			StreamName:    "Snapshot",
+			Handler:       _Maintenance_Snapshot_Handler,
+			ServerStreams: true,
+		},
+	},
+	Metadata: "rpc.proto",
+}
+
+// Client API for Auth service
+
+type AuthClient interface {
+	// AuthEnable enables authentication.
+	AuthEnable(ctx context.Context, in *AuthEnableRequest, opts ...grpc.CallOption) (*AuthEnableResponse, error)
+	// AuthDisable disables authentication.
+	AuthDisable(ctx context.Context, in *AuthDisableRequest, opts ...grpc.CallOption) (*AuthDisableResponse, error)
+	// Authenticate processes an authenticate request.
+	Authenticate(ctx context.Context, in *AuthenticateRequest, opts ...grpc.CallOption) (*AuthenticateResponse, error)
+	// UserAdd adds a new user.
+	UserAdd(ctx context.Context, in *AuthUserAddRequest, opts ...grpc.CallOption) (*AuthUserAddResponse, error)
+	// UserGet gets detailed user information.
+	UserGet(ctx context.Context, in *AuthUserGetRequest, opts ...grpc.CallOption) (*AuthUserGetResponse, error)
+	// UserList gets a list of all users.
+	UserList(ctx context.Context, in *AuthUserListRequest, opts ...grpc.CallOption) (*AuthUserListResponse, error)
+	// UserDelete deletes a specified user.
+	UserDelete(ctx context.Context, in *AuthUserDeleteRequest, opts ...grpc.CallOption) (*AuthUserDeleteResponse, error)
+	// UserChangePassword changes the password of a specified user.
+	UserChangePassword(ctx context.Context, in *AuthUserChangePasswordRequest, opts ...grpc.CallOption) (*AuthUserChangePasswordResponse, error)
+	// UserGrant grants a role to a specified user.
+	UserGrantRole(ctx context.Context, in *AuthUserGrantRoleRequest, opts ...grpc.CallOption) (*AuthUserGrantRoleResponse, error)
+	// UserRevokeRole revokes a role of specified user.
+	UserRevokeRole(ctx context.Context, in *AuthUserRevokeRoleRequest, opts ...grpc.CallOption) (*AuthUserRevokeRoleResponse, error)
+	// RoleAdd adds a new role.
+	RoleAdd(ctx context.Context, in *AuthRoleAddRequest, opts ...grpc.CallOption) (*AuthRoleAddResponse, error)
+	// RoleGet gets detailed role information.
+	RoleGet(ctx context.Context, in *AuthRoleGetRequest, opts ...grpc.CallOption) (*AuthRoleGetResponse, error)
+	// RoleList gets lists of all roles.
+	RoleList(ctx context.Context, in *AuthRoleListRequest, opts ...grpc.CallOption) (*AuthRoleListResponse, error)
+	// RoleDelete deletes a specified role.
+	RoleDelete(ctx context.Context, in *AuthRoleDeleteRequest, opts ...grpc.CallOption) (*AuthRoleDeleteResponse, error)
+	// RoleGrantPermission grants a permission of a specified key or range to a specified role.
+	RoleGrantPermission(ctx context.Context, in *AuthRoleGrantPermissionRequest, opts ...grpc.CallOption) (*AuthRoleGrantPermissionResponse, error)
+	// RoleRevokePermission revokes a key or range permission of a specified role.
+	RoleRevokePermission(ctx context.Context, in *AuthRoleRevokePermissionRequest, opts ...grpc.CallOption) (*AuthRoleRevokePermissionResponse, error)
+}
+
+type authClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewAuthClient(cc *grpc.ClientConn) AuthClient {
+	return &authClient{cc}
+}
+
+func (c *authClient) AuthEnable(ctx context.Context, in *AuthEnableRequest, opts ...grpc.CallOption) (*AuthEnableResponse, error) {
+	out := new(AuthEnableResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/AuthEnable", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) AuthDisable(ctx context.Context, in *AuthDisableRequest, opts ...grpc.CallOption) (*AuthDisableResponse, error) {
+	out := new(AuthDisableResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/AuthDisable", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) Authenticate(ctx context.Context, in *AuthenticateRequest, opts ...grpc.CallOption) (*AuthenticateResponse, error) {
+	out := new(AuthenticateResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/Authenticate", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) UserAdd(ctx context.Context, in *AuthUserAddRequest, opts ...grpc.CallOption) (*AuthUserAddResponse, error) {
+	out := new(AuthUserAddResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/UserAdd", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) UserGet(ctx context.Context, in *AuthUserGetRequest, opts ...grpc.CallOption) (*AuthUserGetResponse, error) {
+	out := new(AuthUserGetResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/UserGet", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) UserList(ctx context.Context, in *AuthUserListRequest, opts ...grpc.CallOption) (*AuthUserListResponse, error) {
+	out := new(AuthUserListResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/UserList", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) UserDelete(ctx context.Context, in *AuthUserDeleteRequest, opts ...grpc.CallOption) (*AuthUserDeleteResponse, error) {
+	out := new(AuthUserDeleteResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/UserDelete", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) UserChangePassword(ctx context.Context, in *AuthUserChangePasswordRequest, opts ...grpc.CallOption) (*AuthUserChangePasswordResponse, error) {
+	out := new(AuthUserChangePasswordResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/UserChangePassword", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) UserGrantRole(ctx context.Context, in *AuthUserGrantRoleRequest, opts ...grpc.CallOption) (*AuthUserGrantRoleResponse, error) {
+	out := new(AuthUserGrantRoleResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/UserGrantRole", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) UserRevokeRole(ctx context.Context, in *AuthUserRevokeRoleRequest, opts ...grpc.CallOption) (*AuthUserRevokeRoleResponse, error) {
+	out := new(AuthUserRevokeRoleResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/UserRevokeRole", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) RoleAdd(ctx context.Context, in *AuthRoleAddRequest, opts ...grpc.CallOption) (*AuthRoleAddResponse, error) {
+	out := new(AuthRoleAddResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/RoleAdd", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) RoleGet(ctx context.Context, in *AuthRoleGetRequest, opts ...grpc.CallOption) (*AuthRoleGetResponse, error) {
+	out := new(AuthRoleGetResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/RoleGet", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) RoleList(ctx context.Context, in *AuthRoleListRequest, opts ...grpc.CallOption) (*AuthRoleListResponse, error) {
+	out := new(AuthRoleListResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/RoleList", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) RoleDelete(ctx context.Context, in *AuthRoleDeleteRequest, opts ...grpc.CallOption) (*AuthRoleDeleteResponse, error) {
+	out := new(AuthRoleDeleteResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/RoleDelete", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) RoleGrantPermission(ctx context.Context, in *AuthRoleGrantPermissionRequest, opts ...grpc.CallOption) (*AuthRoleGrantPermissionResponse, error) {
+	out := new(AuthRoleGrantPermissionResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/RoleGrantPermission", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+func (c *authClient) RoleRevokePermission(ctx context.Context, in *AuthRoleRevokePermissionRequest, opts ...grpc.CallOption) (*AuthRoleRevokePermissionResponse, error) {
+	out := new(AuthRoleRevokePermissionResponse)
+	err := grpc.Invoke(ctx, "/etcdserverpb.Auth/RoleRevokePermission", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Auth service
+
+type AuthServer interface {
+	// AuthEnable enables authentication.
+	AuthEnable(context.Context, *AuthEnableRequest) (*AuthEnableResponse, error)
+	// AuthDisable disables authentication.
+	AuthDisable(context.Context, *AuthDisableRequest) (*AuthDisableResponse, error)
+	// Authenticate processes an authenticate request.
+	Authenticate(context.Context, *AuthenticateRequest) (*AuthenticateResponse, error)
+	// UserAdd adds a new user.
+	UserAdd(context.Context, *AuthUserAddRequest) (*AuthUserAddResponse, error)
+	// UserGet gets detailed user information.
+	UserGet(context.Context, *AuthUserGetRequest) (*AuthUserGetResponse, error)
+	// UserList gets a list of all users.
+	UserList(context.Context, *AuthUserListRequest) (*AuthUserListResponse, error)
+	// UserDelete deletes a specified user.
+	UserDelete(context.Context, *AuthUserDeleteRequest) (*AuthUserDeleteResponse, error)
+	// UserChangePassword changes the password of a specified user.
+	UserChangePassword(context.Context, *AuthUserChangePasswordRequest) (*AuthUserChangePasswordResponse, error)
+	// UserGrant grants a role to a specified user.
+	UserGrantRole(context.Context, *AuthUserGrantRoleRequest) (*AuthUserGrantRoleResponse, error)
+	// UserRevokeRole revokes a role of specified user.
+	UserRevokeRole(context.Context, *AuthUserRevokeRoleRequest) (*AuthUserRevokeRoleResponse, error)
+	// RoleAdd adds a new role.
+	RoleAdd(context.Context, *AuthRoleAddRequest) (*AuthRoleAddResponse, error)
+	// RoleGet gets detailed role information.
+	RoleGet(context.Context, *AuthRoleGetRequest) (*AuthRoleGetResponse, error)
+	// RoleList gets lists of all roles.
+	RoleList(context.Context, *AuthRoleListRequest) (*AuthRoleListResponse, error)
+	// RoleDelete deletes a specified role.
+	RoleDelete(context.Context, *AuthRoleDeleteRequest) (*AuthRoleDeleteResponse, error)
+	// RoleGrantPermission grants a permission of a specified key or range to a specified role.
+	RoleGrantPermission(context.Context, *AuthRoleGrantPermissionRequest) (*AuthRoleGrantPermissionResponse, error)
+	// RoleRevokePermission revokes a key or range permission of a specified role.
+	RoleRevokePermission(context.Context, *AuthRoleRevokePermissionRequest) (*AuthRoleRevokePermissionResponse, error)
+}
+
+func RegisterAuthServer(s *grpc.Server, srv AuthServer) {
+	s.RegisterService(&_Auth_serviceDesc, srv)
+}
+
+func _Auth_AuthEnable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthEnableRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).AuthEnable(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/AuthEnable",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).AuthEnable(ctx, req.(*AuthEnableRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_AuthDisable_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthDisableRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).AuthDisable(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/AuthDisable",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).AuthDisable(ctx, req.(*AuthDisableRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_Authenticate_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthenticateRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).Authenticate(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/Authenticate",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).Authenticate(ctx, req.(*AuthenticateRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_UserAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthUserAddRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).UserAdd(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/UserAdd",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).UserAdd(ctx, req.(*AuthUserAddRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_UserGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthUserGetRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).UserGet(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/UserGet",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).UserGet(ctx, req.(*AuthUserGetRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_UserList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthUserListRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).UserList(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/UserList",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).UserList(ctx, req.(*AuthUserListRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_UserDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthUserDeleteRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).UserDelete(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/UserDelete",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).UserDelete(ctx, req.(*AuthUserDeleteRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_UserChangePassword_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthUserChangePasswordRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).UserChangePassword(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/UserChangePassword",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).UserChangePassword(ctx, req.(*AuthUserChangePasswordRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_UserGrantRole_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthUserGrantRoleRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).UserGrantRole(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/UserGrantRole",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).UserGrantRole(ctx, req.(*AuthUserGrantRoleRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_UserRevokeRole_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthUserRevokeRoleRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).UserRevokeRole(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/UserRevokeRole",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).UserRevokeRole(ctx, req.(*AuthUserRevokeRoleRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_RoleAdd_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthRoleAddRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).RoleAdd(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/RoleAdd",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).RoleAdd(ctx, req.(*AuthRoleAddRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_RoleGet_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthRoleGetRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).RoleGet(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/RoleGet",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).RoleGet(ctx, req.(*AuthRoleGetRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_RoleList_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthRoleListRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).RoleList(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/RoleList",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).RoleList(ctx, req.(*AuthRoleListRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_RoleDelete_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthRoleDeleteRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).RoleDelete(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/RoleDelete",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).RoleDelete(ctx, req.(*AuthRoleDeleteRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_RoleGrantPermission_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthRoleGrantPermissionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).RoleGrantPermission(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/RoleGrantPermission",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).RoleGrantPermission(ctx, req.(*AuthRoleGrantPermissionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+func _Auth_RoleRevokePermission_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(AuthRoleRevokePermissionRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(AuthServer).RoleRevokePermission(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/etcdserverpb.Auth/RoleRevokePermission",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(AuthServer).RoleRevokePermission(ctx, req.(*AuthRoleRevokePermissionRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Auth_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "etcdserverpb.Auth",
+	HandlerType: (*AuthServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "AuthEnable",
+			Handler:    _Auth_AuthEnable_Handler,
+		},
+		{
+			MethodName: "AuthDisable",
+			Handler:    _Auth_AuthDisable_Handler,
+		},
+		{
+			MethodName: "Authenticate",
+			Handler:    _Auth_Authenticate_Handler,
+		},
+		{
+			MethodName: "UserAdd",
+			Handler:    _Auth_UserAdd_Handler,
+		},
+		{
+			MethodName: "UserGet",
+			Handler:    _Auth_UserGet_Handler,
+		},
+		{
+			MethodName: "UserList",
+			Handler:    _Auth_UserList_Handler,
+		},
+		{
+			MethodName: "UserDelete",
+			Handler:    _Auth_UserDelete_Handler,
+		},
+		{
+			MethodName: "UserChangePassword",
+			Handler:    _Auth_UserChangePassword_Handler,
+		},
+		{
+			MethodName: "UserGrantRole",
+			Handler:    _Auth_UserGrantRole_Handler,
+		},
+		{
+			MethodName: "UserRevokeRole",
+			Handler:    _Auth_UserRevokeRole_Handler,
+		},
+		{
+			MethodName: "RoleAdd",
+			Handler:    _Auth_RoleAdd_Handler,
+		},
+		{
+			MethodName: "RoleGet",
+			Handler:    _Auth_RoleGet_Handler,
+		},
+		{
+			MethodName: "RoleList",
+			Handler:    _Auth_RoleList_Handler,
+		},
+		{
+			MethodName: "RoleDelete",
+			Handler:    _Auth_RoleDelete_Handler,
+		},
+		{
+			MethodName: "RoleGrantPermission",
+			Handler:    _Auth_RoleGrantPermission_Handler,
+		},
+		{
+			MethodName: "RoleRevokePermission",
+			Handler:    _Auth_RoleRevokePermission_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "rpc.proto",
+}
+
+func (m *ResponseHeader) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ResponseHeader) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.ClusterId != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ClusterId))
+	}
+	if m.MemberId != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.MemberId))
+	}
+	if m.Revision != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Revision))
+	}
+	if m.RaftTerm != 0 {
+		dAtA[i] = 0x20
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.RaftTerm))
+	}
+	return i, nil
+}
+
+func (m *RangeRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *RangeRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Key) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Key)))
+		i += copy(dAtA[i:], m.Key)
+	}
+	if len(m.RangeEnd) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.RangeEnd)))
+		i += copy(dAtA[i:], m.RangeEnd)
+	}
+	if m.Limit != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Limit))
+	}
+	if m.Revision != 0 {
+		dAtA[i] = 0x20
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Revision))
+	}
+	if m.SortOrder != 0 {
+		dAtA[i] = 0x28
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.SortOrder))
+	}
+	if m.SortTarget != 0 {
+		dAtA[i] = 0x30
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.SortTarget))
+	}
+	if m.Serializable {
+		dAtA[i] = 0x38
+		i++
+		if m.Serializable {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.KeysOnly {
+		dAtA[i] = 0x40
+		i++
+		if m.KeysOnly {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.CountOnly {
+		dAtA[i] = 0x48
+		i++
+		if m.CountOnly {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.MinModRevision != 0 {
+		dAtA[i] = 0x50
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.MinModRevision))
+	}
+	if m.MaxModRevision != 0 {
+		dAtA[i] = 0x58
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.MaxModRevision))
+	}
+	if m.MinCreateRevision != 0 {
+		dAtA[i] = 0x60
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.MinCreateRevision))
+	}
+	if m.MaxCreateRevision != 0 {
+		dAtA[i] = 0x68
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.MaxCreateRevision))
+	}
+	return i, nil
+}
+
+func (m *RangeResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *RangeResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n1, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n1
+	}
+	if len(m.Kvs) > 0 {
+		for _, msg := range m.Kvs {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	if m.More {
+		dAtA[i] = 0x18
+		i++
+		if m.More {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.Count != 0 {
+		dAtA[i] = 0x20
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Count))
+	}
+	return i, nil
+}
+
+func (m *PutRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *PutRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Key) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Key)))
+		i += copy(dAtA[i:], m.Key)
+	}
+	if len(m.Value) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Value)))
+		i += copy(dAtA[i:], m.Value)
+	}
+	if m.Lease != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Lease))
+	}
+	if m.PrevKv {
+		dAtA[i] = 0x20
+		i++
+		if m.PrevKv {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.IgnoreValue {
+		dAtA[i] = 0x28
+		i++
+		if m.IgnoreValue {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.IgnoreLease {
+		dAtA[i] = 0x30
+		i++
+		if m.IgnoreLease {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	return i, nil
+}
+
+func (m *PutResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *PutResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n2, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n2
+	}
+	if m.PrevKv != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.PrevKv.Size()))
+		n3, err := m.PrevKv.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n3
+	}
+	return i, nil
+}
+
+func (m *DeleteRangeRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *DeleteRangeRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Key) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Key)))
+		i += copy(dAtA[i:], m.Key)
+	}
+	if len(m.RangeEnd) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.RangeEnd)))
+		i += copy(dAtA[i:], m.RangeEnd)
+	}
+	if m.PrevKv {
+		dAtA[i] = 0x18
+		i++
+		if m.PrevKv {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	return i, nil
+}
+
+func (m *DeleteRangeResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *DeleteRangeResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n4, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n4
+	}
+	if m.Deleted != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Deleted))
+	}
+	if len(m.PrevKvs) > 0 {
+		for _, msg := range m.PrevKvs {
+			dAtA[i] = 0x1a
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	return i, nil
+}
+
+func (m *RequestOp) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *RequestOp) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Request != nil {
+		nn5, err := m.Request.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += nn5
+	}
+	return i, nil
+}
+
+func (m *RequestOp_RequestRange) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	if m.RequestRange != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.RequestRange.Size()))
+		n6, err := m.RequestRange.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n6
+	}
+	return i, nil
+}
+func (m *RequestOp_RequestPut) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	if m.RequestPut != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.RequestPut.Size()))
+		n7, err := m.RequestPut.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n7
+	}
+	return i, nil
+}
+func (m *RequestOp_RequestDeleteRange) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	if m.RequestDeleteRange != nil {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.RequestDeleteRange.Size()))
+		n8, err := m.RequestDeleteRange.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n8
+	}
+	return i, nil
+}
+func (m *RequestOp_RequestTxn) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	if m.RequestTxn != nil {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.RequestTxn.Size()))
+		n9, err := m.RequestTxn.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n9
+	}
+	return i, nil
+}
+func (m *ResponseOp) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *ResponseOp) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Response != nil {
+		nn10, err := m.Response.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += nn10
+	}
+	return i, nil
+}
+
+func (m *ResponseOp_ResponseRange) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	if m.ResponseRange != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ResponseRange.Size()))
+		n11, err := m.ResponseRange.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n11
+	}
+	return i, nil
+}
+func (m *ResponseOp_ResponsePut) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	if m.ResponsePut != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ResponsePut.Size()))
+		n12, err := m.ResponsePut.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n12
+	}
+	return i, nil
+}
+func (m *ResponseOp_ResponseDeleteRange) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	if m.ResponseDeleteRange != nil {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ResponseDeleteRange.Size()))
+		n13, err := m.ResponseDeleteRange.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n13
+	}
+	return i, nil
+}
+func (m *ResponseOp_ResponseTxn) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	if m.ResponseTxn != nil {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ResponseTxn.Size()))
+		n14, err := m.ResponseTxn.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n14
+	}
+	return i, nil
+}
+func (m *Compare) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Compare) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Result != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Result))
+	}
+	if m.Target != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Target))
+	}
+	if len(m.Key) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Key)))
+		i += copy(dAtA[i:], m.Key)
+	}
+	if m.TargetUnion != nil {
+		nn15, err := m.TargetUnion.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += nn15
+	}
+	if len(m.RangeEnd) > 0 {
+		dAtA[i] = 0x82
+		i++
+		dAtA[i] = 0x4
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.RangeEnd)))
+		i += copy(dAtA[i:], m.RangeEnd)
+	}
+	return i, nil
+}
+
+func (m *Compare_Version) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	dAtA[i] = 0x20
+	i++
+	i = encodeVarintRpc(dAtA, i, uint64(m.Version))
+	return i, nil
+}
+func (m *Compare_CreateRevision) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	dAtA[i] = 0x28
+	i++
+	i = encodeVarintRpc(dAtA, i, uint64(m.CreateRevision))
+	return i, nil
+}
+func (m *Compare_ModRevision) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	dAtA[i] = 0x30
+	i++
+	i = encodeVarintRpc(dAtA, i, uint64(m.ModRevision))
+	return i, nil
+}
+func (m *Compare_Value) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	if m.Value != nil {
+		dAtA[i] = 0x3a
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Value)))
+		i += copy(dAtA[i:], m.Value)
+	}
+	return i, nil
+}
+func (m *Compare_Lease) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	dAtA[i] = 0x40
+	i++
+	i = encodeVarintRpc(dAtA, i, uint64(m.Lease))
+	return i, nil
+}
+func (m *TxnRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *TxnRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Compare) > 0 {
+		for _, msg := range m.Compare {
+			dAtA[i] = 0xa
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	if len(m.Success) > 0 {
+		for _, msg := range m.Success {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	if len(m.Failure) > 0 {
+		for _, msg := range m.Failure {
+			dAtA[i] = 0x1a
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	return i, nil
+}
+
+func (m *TxnResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *TxnResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n16, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n16
+	}
+	if m.Succeeded {
+		dAtA[i] = 0x10
+		i++
+		if m.Succeeded {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if len(m.Responses) > 0 {
+		for _, msg := range m.Responses {
+			dAtA[i] = 0x1a
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	return i, nil
+}
+
+func (m *CompactionRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *CompactionRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Revision != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Revision))
+	}
+	if m.Physical {
+		dAtA[i] = 0x10
+		i++
+		if m.Physical {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	return i, nil
+}
+
+func (m *CompactionResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *CompactionResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n17, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n17
+	}
+	return i, nil
+}
+
+func (m *HashRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *HashRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	return i, nil
+}
+
+func (m *HashKVRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *HashKVRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Revision != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Revision))
+	}
+	return i, nil
+}
+
+func (m *HashKVResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *HashKVResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n18, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n18
+	}
+	if m.Hash != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Hash))
+	}
+	if m.CompactRevision != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.CompactRevision))
+	}
+	return i, nil
+}
+
+func (m *HashResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *HashResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n19, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n19
+	}
+	if m.Hash != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Hash))
+	}
+	return i, nil
+}
+
+func (m *SnapshotRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *SnapshotRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	return i, nil
+}
+
+func (m *SnapshotResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *SnapshotResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n20, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n20
+	}
+	if m.RemainingBytes != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.RemainingBytes))
+	}
+	if len(m.Blob) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Blob)))
+		i += copy(dAtA[i:], m.Blob)
+	}
+	return i, nil
+}
+
+func (m *WatchRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *WatchRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.RequestUnion != nil {
+		nn21, err := m.RequestUnion.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += nn21
+	}
+	return i, nil
+}
+
+func (m *WatchRequest_CreateRequest) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	if m.CreateRequest != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.CreateRequest.Size()))
+		n22, err := m.CreateRequest.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n22
+	}
+	return i, nil
+}
+func (m *WatchRequest_CancelRequest) MarshalTo(dAtA []byte) (int, error) {
+	i := 0
+	if m.CancelRequest != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.CancelRequest.Size()))
+		n23, err := m.CancelRequest.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n23
+	}
+	return i, nil
+}
+func (m *WatchCreateRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *WatchCreateRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Key) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Key)))
+		i += copy(dAtA[i:], m.Key)
+	}
+	if len(m.RangeEnd) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.RangeEnd)))
+		i += copy(dAtA[i:], m.RangeEnd)
+	}
+	if m.StartRevision != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.StartRevision))
+	}
+	if m.ProgressNotify {
+		dAtA[i] = 0x20
+		i++
+		if m.ProgressNotify {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if len(m.Filters) > 0 {
+		dAtA25 := make([]byte, len(m.Filters)*10)
+		var j24 int
+		for _, num := range m.Filters {
+			for num >= 1<<7 {
+				dAtA25[j24] = uint8(uint64(num)&0x7f | 0x80)
+				num >>= 7
+				j24++
+			}
+			dAtA25[j24] = uint8(num)
+			j24++
+		}
+		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(j24))
+		i += copy(dAtA[i:], dAtA25[:j24])
+	}
+	if m.PrevKv {
+		dAtA[i] = 0x30
+		i++
+		if m.PrevKv {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	return i, nil
+}
+
+func (m *WatchCancelRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *WatchCancelRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.WatchId != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.WatchId))
+	}
+	return i, nil
+}
+
+func (m *WatchResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *WatchResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n26, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n26
+	}
+	if m.WatchId != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.WatchId))
+	}
+	if m.Created {
+		dAtA[i] = 0x18
+		i++
+		if m.Created {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.Canceled {
+		dAtA[i] = 0x20
+		i++
+		if m.Canceled {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	if m.CompactRevision != 0 {
+		dAtA[i] = 0x28
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.CompactRevision))
+	}
+	if len(m.CancelReason) > 0 {
+		dAtA[i] = 0x32
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.CancelReason)))
+		i += copy(dAtA[i:], m.CancelReason)
+	}
+	if len(m.Events) > 0 {
+		for _, msg := range m.Events {
+			dAtA[i] = 0x5a
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	return i, nil
+}
+
+func (m *LeaseGrantRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseGrantRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.TTL != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.TTL))
+	}
+	if m.ID != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
+	}
+	return i, nil
+}
+
+func (m *LeaseGrantResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseGrantResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n27, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n27
+	}
+	if m.ID != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
+	}
+	if m.TTL != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.TTL))
+	}
+	if len(m.Error) > 0 {
+		dAtA[i] = 0x22
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Error)))
+		i += copy(dAtA[i:], m.Error)
+	}
+	return i, nil
+}
+
+func (m *LeaseRevokeRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseRevokeRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.ID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
+	}
+	return i, nil
+}
+
+func (m *LeaseRevokeResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseRevokeResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n28, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n28
+	}
+	return i, nil
+}
+
+func (m *LeaseKeepAliveRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseKeepAliveRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.ID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
+	}
+	return i, nil
+}
+
+func (m *LeaseKeepAliveResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseKeepAliveResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n29, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n29
+	}
+	if m.ID != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
+	}
+	if m.TTL != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.TTL))
+	}
+	return i, nil
+}
+
+func (m *LeaseTimeToLiveRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseTimeToLiveRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.ID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
+	}
+	if m.Keys {
+		dAtA[i] = 0x10
+		i++
+		if m.Keys {
+			dAtA[i] = 1
+		} else {
+			dAtA[i] = 0
+		}
+		i++
+	}
+	return i, nil
+}
+
+func (m *LeaseTimeToLiveResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseTimeToLiveResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n30, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n30
+	}
+	if m.ID != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
+	}
+	if m.TTL != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.TTL))
+	}
+	if m.GrantedTTL != 0 {
+		dAtA[i] = 0x20
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.GrantedTTL))
+	}
+	if len(m.Keys) > 0 {
+		for _, b := range m.Keys {
+			dAtA[i] = 0x2a
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(len(b)))
+			i += copy(dAtA[i:], b)
+		}
+	}
+	return i, nil
+}
+
+func (m *LeaseLeasesRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseLeasesRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	return i, nil
+}
+
+func (m *LeaseStatus) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseStatus) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.ID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
+	}
+	return i, nil
+}
+
+func (m *LeaseLeasesResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *LeaseLeasesResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n31, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n31
+	}
+	if len(m.Leases) > 0 {
+		for _, msg := range m.Leases {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	return i, nil
+}
+
+func (m *Member) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Member) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.ID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
+	}
+	if len(m.Name) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	if len(m.PeerURLs) > 0 {
+		for _, s := range m.PeerURLs {
+			dAtA[i] = 0x1a
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
+	}
+	if len(m.ClientURLs) > 0 {
+		for _, s := range m.ClientURLs {
+			dAtA[i] = 0x22
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
+	}
+	return i, nil
+}
+
+func (m *MemberAddRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MemberAddRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.PeerURLs) > 0 {
+		for _, s := range m.PeerURLs {
+			dAtA[i] = 0xa
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
+	}
+	return i, nil
+}
+
+func (m *MemberAddResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MemberAddResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n32, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n32
+	}
+	if m.Member != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Member.Size()))
+		n33, err := m.Member.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n33
+	}
+	if len(m.Members) > 0 {
+		for _, msg := range m.Members {
+			dAtA[i] = 0x1a
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	return i, nil
+}
+
+func (m *MemberRemoveRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MemberRemoveRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.ID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
+	}
+	return i, nil
+}
+
+func (m *MemberRemoveResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MemberRemoveResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n34, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n34
+	}
+	if len(m.Members) > 0 {
+		for _, msg := range m.Members {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	return i, nil
+}
+
+func (m *MemberUpdateRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MemberUpdateRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.ID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.ID))
+	}
+	if len(m.PeerURLs) > 0 {
+		for _, s := range m.PeerURLs {
+			dAtA[i] = 0x12
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
+	}
+	return i, nil
+}
+
+func (m *MemberUpdateResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MemberUpdateResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n35, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n35
+	}
+	if len(m.Members) > 0 {
+		for _, msg := range m.Members {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	return i, nil
+}
+
+func (m *MemberListRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MemberListRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	return i, nil
+}
+
+func (m *MemberListResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MemberListResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n36, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n36
+	}
+	if len(m.Members) > 0 {
+		for _, msg := range m.Members {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	return i, nil
+}
+
+func (m *DefragmentRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *DefragmentRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	return i, nil
+}
+
+func (m *DefragmentResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *DefragmentResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n37, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n37
+	}
+	return i, nil
+}
+
+func (m *MoveLeaderRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MoveLeaderRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.TargetID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.TargetID))
+	}
+	return i, nil
+}
+
+func (m *MoveLeaderResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *MoveLeaderResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n38, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n38
+	}
+	return i, nil
+}
+
+func (m *AlarmRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AlarmRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Action != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Action))
+	}
+	if m.MemberID != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.MemberID))
+	}
+	if m.Alarm != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Alarm))
+	}
+	return i, nil
+}
+
+func (m *AlarmMember) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AlarmMember) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.MemberID != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.MemberID))
+	}
+	if m.Alarm != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Alarm))
+	}
+	return i, nil
+}
+
+func (m *AlarmResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AlarmResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n39, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n39
+	}
+	if len(m.Alarms) > 0 {
+		for _, msg := range m.Alarms {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	return i, nil
+}
+
+func (m *StatusRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *StatusRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	return i, nil
+}
+
+func (m *StatusResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *StatusResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n40, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n40
+	}
+	if len(m.Version) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Version)))
+		i += copy(dAtA[i:], m.Version)
+	}
+	if m.DbSize != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.DbSize))
+	}
+	if m.Leader != 0 {
+		dAtA[i] = 0x20
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Leader))
+	}
+	if m.RaftIndex != 0 {
+		dAtA[i] = 0x28
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.RaftIndex))
+	}
+	if m.RaftTerm != 0 {
+		dAtA[i] = 0x30
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.RaftTerm))
+	}
+	return i, nil
+}
+
+func (m *AuthEnableRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthEnableRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	return i, nil
+}
+
+func (m *AuthDisableRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthDisableRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	return i, nil
+}
+
+func (m *AuthenticateRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthenticateRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	if len(m.Password) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Password)))
+		i += copy(dAtA[i:], m.Password)
+	}
+	return i, nil
+}
+
+func (m *AuthUserAddRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthUserAddRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	if len(m.Password) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Password)))
+		i += copy(dAtA[i:], m.Password)
+	}
+	return i, nil
+}
+
+func (m *AuthUserGetRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthUserGetRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	return i, nil
+}
+
+func (m *AuthUserDeleteRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthUserDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	return i, nil
+}
+
+func (m *AuthUserChangePasswordRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthUserChangePasswordRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	if len(m.Password) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Password)))
+		i += copy(dAtA[i:], m.Password)
+	}
+	return i, nil
+}
+
+func (m *AuthUserGrantRoleRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthUserGrantRoleRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.User) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.User)))
+		i += copy(dAtA[i:], m.User)
+	}
+	if len(m.Role) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Role)))
+		i += copy(dAtA[i:], m.Role)
+	}
+	return i, nil
+}
+
+func (m *AuthUserRevokeRoleRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthUserRevokeRoleRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	if len(m.Role) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Role)))
+		i += copy(dAtA[i:], m.Role)
+	}
+	return i, nil
+}
+
+func (m *AuthRoleAddRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthRoleAddRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	return i, nil
+}
+
+func (m *AuthRoleGetRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthRoleGetRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Role) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Role)))
+		i += copy(dAtA[i:], m.Role)
+	}
+	return i, nil
+}
+
+func (m *AuthUserListRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthUserListRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	return i, nil
+}
+
+func (m *AuthRoleListRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthRoleListRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	return i, nil
+}
+
+func (m *AuthRoleDeleteRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthRoleDeleteRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Role) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Role)))
+		i += copy(dAtA[i:], m.Role)
+	}
+	return i, nil
+}
+
+func (m *AuthRoleGrantPermissionRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthRoleGrantPermissionRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Name) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Name)))
+		i += copy(dAtA[i:], m.Name)
+	}
+	if m.Perm != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Perm.Size()))
+		n41, err := m.Perm.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n41
+	}
+	return i, nil
+}
+
+func (m *AuthRoleRevokePermissionRequest) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthRoleRevokePermissionRequest) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Role) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Role)))
+		i += copy(dAtA[i:], m.Role)
+	}
+	if len(m.Key) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Key)))
+		i += copy(dAtA[i:], m.Key)
+	}
+	if len(m.RangeEnd) > 0 {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.RangeEnd)))
+		i += copy(dAtA[i:], m.RangeEnd)
+	}
+	return i, nil
+}
+
+func (m *AuthEnableResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthEnableResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n42, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n42
+	}
+	return i, nil
+}
+
+func (m *AuthDisableResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthDisableResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n43, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n43
+	}
+	return i, nil
+}
+
+func (m *AuthenticateResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthenticateResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n44, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n44
+	}
+	if len(m.Token) > 0 {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(len(m.Token)))
+		i += copy(dAtA[i:], m.Token)
+	}
+	return i, nil
+}
+
+func (m *AuthUserAddResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthUserAddResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n45, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n45
+	}
+	return i, nil
+}
+
+func (m *AuthUserGetResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthUserGetResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n46, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n46
+	}
+	if len(m.Roles) > 0 {
+		for _, s := range m.Roles {
+			dAtA[i] = 0x12
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
+	}
+	return i, nil
+}
+
+func (m *AuthUserDeleteResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthUserDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n47, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n47
+	}
+	return i, nil
+}
+
+func (m *AuthUserChangePasswordResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthUserChangePasswordResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n48, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n48
+	}
+	return i, nil
+}
+
+func (m *AuthUserGrantRoleResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthUserGrantRoleResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n49, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n49
+	}
+	return i, nil
+}
+
+func (m *AuthUserRevokeRoleResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthUserRevokeRoleResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n50, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n50
+	}
+	return i, nil
+}
+
+func (m *AuthRoleAddResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthRoleAddResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n51, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n51
+	}
+	return i, nil
+}
+
+func (m *AuthRoleGetResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthRoleGetResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n52, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n52
+	}
+	if len(m.Perm) > 0 {
+		for _, msg := range m.Perm {
+			dAtA[i] = 0x12
+			i++
+			i = encodeVarintRpc(dAtA, i, uint64(msg.Size()))
+			n, err := msg.MarshalTo(dAtA[i:])
+			if err != nil {
+				return 0, err
+			}
+			i += n
+		}
+	}
+	return i, nil
+}
+
+func (m *AuthRoleListResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthRoleListResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n53, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n53
+	}
+	if len(m.Roles) > 0 {
+		for _, s := range m.Roles {
+			dAtA[i] = 0x12
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
+	}
+	return i, nil
+}
+
+func (m *AuthUserListResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthUserListResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n54, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n54
+	}
+	if len(m.Users) > 0 {
+		for _, s := range m.Users {
+			dAtA[i] = 0x12
+			i++
+			l = len(s)
+			for l >= 1<<7 {
+				dAtA[i] = uint8(uint64(l)&0x7f | 0x80)
+				l >>= 7
+				i++
+			}
+			dAtA[i] = uint8(l)
+			i++
+			i += copy(dAtA[i:], s)
+		}
+	}
+	return i, nil
+}
+
+func (m *AuthRoleDeleteResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthRoleDeleteResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n55, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n55
+	}
+	return i, nil
+}
+
+func (m *AuthRoleGrantPermissionResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthRoleGrantPermissionResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n56, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n56
+	}
+	return i, nil
+}
+
+func (m *AuthRoleRevokePermissionResponse) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *AuthRoleRevokePermissionResponse) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Header != nil {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintRpc(dAtA, i, uint64(m.Header.Size()))
+		n57, err := m.Header.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n57
+	}
+	return i, nil
+}
+
+func encodeFixed64Rpc(dAtA []byte, offset int, v uint64) int {
+	dAtA[offset] = uint8(v)
+	dAtA[offset+1] = uint8(v >> 8)
+	dAtA[offset+2] = uint8(v >> 16)
+	dAtA[offset+3] = uint8(v >> 24)
+	dAtA[offset+4] = uint8(v >> 32)
+	dAtA[offset+5] = uint8(v >> 40)
+	dAtA[offset+6] = uint8(v >> 48)
+	dAtA[offset+7] = uint8(v >> 56)
+	return offset + 8
+}
+func encodeFixed32Rpc(dAtA []byte, offset int, v uint32) int {
+	dAtA[offset] = uint8(v)
+	dAtA[offset+1] = uint8(v >> 8)
+	dAtA[offset+2] = uint8(v >> 16)
+	dAtA[offset+3] = uint8(v >> 24)
+	return offset + 4
+}
+func encodeVarintRpc(dAtA []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return offset + 1
+}
+func (m *ResponseHeader) Size() (n int) {
+	var l int
+	_ = l
+	if m.ClusterId != 0 {
+		n += 1 + sovRpc(uint64(m.ClusterId))
+	}
+	if m.MemberId != 0 {
+		n += 1 + sovRpc(uint64(m.MemberId))
+	}
+	if m.Revision != 0 {
+		n += 1 + sovRpc(uint64(m.Revision))
+	}
+	if m.RaftTerm != 0 {
+		n += 1 + sovRpc(uint64(m.RaftTerm))
+	}
+	return n
+}
+
+func (m *RangeRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	l = len(m.RangeEnd)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.Limit != 0 {
+		n += 1 + sovRpc(uint64(m.Limit))
+	}
+	if m.Revision != 0 {
+		n += 1 + sovRpc(uint64(m.Revision))
+	}
+	if m.SortOrder != 0 {
+		n += 1 + sovRpc(uint64(m.SortOrder))
+	}
+	if m.SortTarget != 0 {
+		n += 1 + sovRpc(uint64(m.SortTarget))
+	}
+	if m.Serializable {
+		n += 2
+	}
+	if m.KeysOnly {
+		n += 2
+	}
+	if m.CountOnly {
+		n += 2
+	}
+	if m.MinModRevision != 0 {
+		n += 1 + sovRpc(uint64(m.MinModRevision))
+	}
+	if m.MaxModRevision != 0 {
+		n += 1 + sovRpc(uint64(m.MaxModRevision))
+	}
+	if m.MinCreateRevision != 0 {
+		n += 1 + sovRpc(uint64(m.MinCreateRevision))
+	}
+	if m.MaxCreateRevision != 0 {
+		n += 1 + sovRpc(uint64(m.MaxCreateRevision))
+	}
+	return n
+}
+
+func (m *RangeResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if len(m.Kvs) > 0 {
+		for _, e := range m.Kvs {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	if m.More {
+		n += 2
+	}
+	if m.Count != 0 {
+		n += 1 + sovRpc(uint64(m.Count))
+	}
+	return n
+}
+
+func (m *PutRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	l = len(m.Value)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.Lease != 0 {
+		n += 1 + sovRpc(uint64(m.Lease))
+	}
+	if m.PrevKv {
+		n += 2
+	}
+	if m.IgnoreValue {
+		n += 2
+	}
+	if m.IgnoreLease {
+		n += 2
+	}
+	return n
+}
+
+func (m *PutResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.PrevKv != nil {
+		l = m.PrevKv.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *DeleteRangeRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	l = len(m.RangeEnd)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.PrevKv {
+		n += 2
+	}
+	return n
+}
+
+func (m *DeleteRangeResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.Deleted != 0 {
+		n += 1 + sovRpc(uint64(m.Deleted))
+	}
+	if len(m.PrevKvs) > 0 {
+		for _, e := range m.PrevKvs {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *RequestOp) Size() (n int) {
+	var l int
+	_ = l
+	if m.Request != nil {
+		n += m.Request.Size()
+	}
+	return n
+}
+
+func (m *RequestOp_RequestRange) Size() (n int) {
+	var l int
+	_ = l
+	if m.RequestRange != nil {
+		l = m.RequestRange.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+func (m *RequestOp_RequestPut) Size() (n int) {
+	var l int
+	_ = l
+	if m.RequestPut != nil {
+		l = m.RequestPut.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+func (m *RequestOp_RequestDeleteRange) Size() (n int) {
+	var l int
+	_ = l
+	if m.RequestDeleteRange != nil {
+		l = m.RequestDeleteRange.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+func (m *RequestOp_RequestTxn) Size() (n int) {
+	var l int
+	_ = l
+	if m.RequestTxn != nil {
+		l = m.RequestTxn.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+func (m *ResponseOp) Size() (n int) {
+	var l int
+	_ = l
+	if m.Response != nil {
+		n += m.Response.Size()
+	}
+	return n
+}
+
+func (m *ResponseOp_ResponseRange) Size() (n int) {
+	var l int
+	_ = l
+	if m.ResponseRange != nil {
+		l = m.ResponseRange.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+func (m *ResponseOp_ResponsePut) Size() (n int) {
+	var l int
+	_ = l
+	if m.ResponsePut != nil {
+		l = m.ResponsePut.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+func (m *ResponseOp_ResponseDeleteRange) Size() (n int) {
+	var l int
+	_ = l
+	if m.ResponseDeleteRange != nil {
+		l = m.ResponseDeleteRange.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+func (m *ResponseOp_ResponseTxn) Size() (n int) {
+	var l int
+	_ = l
+	if m.ResponseTxn != nil {
+		l = m.ResponseTxn.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+func (m *Compare) Size() (n int) {
+	var l int
+	_ = l
+	if m.Result != 0 {
+		n += 1 + sovRpc(uint64(m.Result))
+	}
+	if m.Target != 0 {
+		n += 1 + sovRpc(uint64(m.Target))
+	}
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.TargetUnion != nil {
+		n += m.TargetUnion.Size()
+	}
+	l = len(m.RangeEnd)
+	if l > 0 {
+		n += 2 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *Compare_Version) Size() (n int) {
+	var l int
+	_ = l
+	n += 1 + sovRpc(uint64(m.Version))
+	return n
+}
+func (m *Compare_CreateRevision) Size() (n int) {
+	var l int
+	_ = l
+	n += 1 + sovRpc(uint64(m.CreateRevision))
+	return n
+}
+func (m *Compare_ModRevision) Size() (n int) {
+	var l int
+	_ = l
+	n += 1 + sovRpc(uint64(m.ModRevision))
+	return n
+}
+func (m *Compare_Value) Size() (n int) {
+	var l int
+	_ = l
+	if m.Value != nil {
+		l = len(m.Value)
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+func (m *Compare_Lease) Size() (n int) {
+	var l int
+	_ = l
+	n += 1 + sovRpc(uint64(m.Lease))
+	return n
+}
+func (m *TxnRequest) Size() (n int) {
+	var l int
+	_ = l
+	if len(m.Compare) > 0 {
+		for _, e := range m.Compare {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	if len(m.Success) > 0 {
+		for _, e := range m.Success {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	if len(m.Failure) > 0 {
+		for _, e := range m.Failure {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *TxnResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.Succeeded {
+		n += 2
+	}
+	if len(m.Responses) > 0 {
+		for _, e := range m.Responses {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *CompactionRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.Revision != 0 {
+		n += 1 + sovRpc(uint64(m.Revision))
+	}
+	if m.Physical {
+		n += 2
+	}
+	return n
+}
+
+func (m *CompactionResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *HashRequest) Size() (n int) {
+	var l int
+	_ = l
+	return n
+}
+
+func (m *HashKVRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.Revision != 0 {
+		n += 1 + sovRpc(uint64(m.Revision))
+	}
+	return n
+}
+
+func (m *HashKVResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.Hash != 0 {
+		n += 1 + sovRpc(uint64(m.Hash))
+	}
+	if m.CompactRevision != 0 {
+		n += 1 + sovRpc(uint64(m.CompactRevision))
+	}
+	return n
+}
+
+func (m *HashResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.Hash != 0 {
+		n += 1 + sovRpc(uint64(m.Hash))
+	}
+	return n
+}
+
+func (m *SnapshotRequest) Size() (n int) {
+	var l int
+	_ = l
+	return n
+}
+
+func (m *SnapshotResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.RemainingBytes != 0 {
+		n += 1 + sovRpc(uint64(m.RemainingBytes))
+	}
+	l = len(m.Blob)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *WatchRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.RequestUnion != nil {
+		n += m.RequestUnion.Size()
+	}
+	return n
+}
+
+func (m *WatchRequest_CreateRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.CreateRequest != nil {
+		l = m.CreateRequest.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+func (m *WatchRequest_CancelRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.CancelRequest != nil {
+		l = m.CancelRequest.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+func (m *WatchCreateRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	l = len(m.RangeEnd)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.StartRevision != 0 {
+		n += 1 + sovRpc(uint64(m.StartRevision))
+	}
+	if m.ProgressNotify {
+		n += 2
+	}
+	if len(m.Filters) > 0 {
+		l = 0
+		for _, e := range m.Filters {
+			l += sovRpc(uint64(e))
+		}
+		n += 1 + sovRpc(uint64(l)) + l
+	}
+	if m.PrevKv {
+		n += 2
+	}
+	return n
+}
+
+func (m *WatchCancelRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.WatchId != 0 {
+		n += 1 + sovRpc(uint64(m.WatchId))
+	}
+	return n
+}
+
+func (m *WatchResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.WatchId != 0 {
+		n += 1 + sovRpc(uint64(m.WatchId))
+	}
+	if m.Created {
+		n += 2
+	}
+	if m.Canceled {
+		n += 2
+	}
+	if m.CompactRevision != 0 {
+		n += 1 + sovRpc(uint64(m.CompactRevision))
+	}
+	l = len(m.CancelReason)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if len(m.Events) > 0 {
+		for _, e := range m.Events {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *LeaseGrantRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.TTL != 0 {
+		n += 1 + sovRpc(uint64(m.TTL))
+	}
+	if m.ID != 0 {
+		n += 1 + sovRpc(uint64(m.ID))
+	}
+	return n
+}
+
+func (m *LeaseGrantResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.ID != 0 {
+		n += 1 + sovRpc(uint64(m.ID))
+	}
+	if m.TTL != 0 {
+		n += 1 + sovRpc(uint64(m.TTL))
+	}
+	l = len(m.Error)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *LeaseRevokeRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.ID != 0 {
+		n += 1 + sovRpc(uint64(m.ID))
+	}
+	return n
+}
+
+func (m *LeaseRevokeResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *LeaseKeepAliveRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.ID != 0 {
+		n += 1 + sovRpc(uint64(m.ID))
+	}
+	return n
+}
+
+func (m *LeaseKeepAliveResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.ID != 0 {
+		n += 1 + sovRpc(uint64(m.ID))
+	}
+	if m.TTL != 0 {
+		n += 1 + sovRpc(uint64(m.TTL))
+	}
+	return n
+}
+
+func (m *LeaseTimeToLiveRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.ID != 0 {
+		n += 1 + sovRpc(uint64(m.ID))
+	}
+	if m.Keys {
+		n += 2
+	}
+	return n
+}
+
+func (m *LeaseTimeToLiveResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.ID != 0 {
+		n += 1 + sovRpc(uint64(m.ID))
+	}
+	if m.TTL != 0 {
+		n += 1 + sovRpc(uint64(m.TTL))
+	}
+	if m.GrantedTTL != 0 {
+		n += 1 + sovRpc(uint64(m.GrantedTTL))
+	}
+	if len(m.Keys) > 0 {
+		for _, b := range m.Keys {
+			l = len(b)
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *LeaseLeasesRequest) Size() (n int) {
+	var l int
+	_ = l
+	return n
+}
+
+func (m *LeaseStatus) Size() (n int) {
+	var l int
+	_ = l
+	if m.ID != 0 {
+		n += 1 + sovRpc(uint64(m.ID))
+	}
+	return n
+}
+
+func (m *LeaseLeasesResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if len(m.Leases) > 0 {
+		for _, e := range m.Leases {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *Member) Size() (n int) {
+	var l int
+	_ = l
+	if m.ID != 0 {
+		n += 1 + sovRpc(uint64(m.ID))
+	}
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if len(m.PeerURLs) > 0 {
+		for _, s := range m.PeerURLs {
+			l = len(s)
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	if len(m.ClientURLs) > 0 {
+		for _, s := range m.ClientURLs {
+			l = len(s)
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *MemberAddRequest) Size() (n int) {
+	var l int
+	_ = l
+	if len(m.PeerURLs) > 0 {
+		for _, s := range m.PeerURLs {
+			l = len(s)
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *MemberAddResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.Member != nil {
+		l = m.Member.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if len(m.Members) > 0 {
+		for _, e := range m.Members {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *MemberRemoveRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.ID != 0 {
+		n += 1 + sovRpc(uint64(m.ID))
+	}
+	return n
+}
+
+func (m *MemberRemoveResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if len(m.Members) > 0 {
+		for _, e := range m.Members {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *MemberUpdateRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.ID != 0 {
+		n += 1 + sovRpc(uint64(m.ID))
+	}
+	if len(m.PeerURLs) > 0 {
+		for _, s := range m.PeerURLs {
+			l = len(s)
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *MemberUpdateResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if len(m.Members) > 0 {
+		for _, e := range m.Members {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *MemberListRequest) Size() (n int) {
+	var l int
+	_ = l
+	return n
+}
+
+func (m *MemberListResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if len(m.Members) > 0 {
+		for _, e := range m.Members {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *DefragmentRequest) Size() (n int) {
+	var l int
+	_ = l
+	return n
+}
+
+func (m *DefragmentResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *MoveLeaderRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.TargetID != 0 {
+		n += 1 + sovRpc(uint64(m.TargetID))
+	}
+	return n
+}
+
+func (m *MoveLeaderResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AlarmRequest) Size() (n int) {
+	var l int
+	_ = l
+	if m.Action != 0 {
+		n += 1 + sovRpc(uint64(m.Action))
+	}
+	if m.MemberID != 0 {
+		n += 1 + sovRpc(uint64(m.MemberID))
+	}
+	if m.Alarm != 0 {
+		n += 1 + sovRpc(uint64(m.Alarm))
+	}
+	return n
+}
+
+func (m *AlarmMember) Size() (n int) {
+	var l int
+	_ = l
+	if m.MemberID != 0 {
+		n += 1 + sovRpc(uint64(m.MemberID))
+	}
+	if m.Alarm != 0 {
+		n += 1 + sovRpc(uint64(m.Alarm))
+	}
+	return n
+}
+
+func (m *AlarmResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if len(m.Alarms) > 0 {
+		for _, e := range m.Alarms {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *StatusRequest) Size() (n int) {
+	var l int
+	_ = l
+	return n
+}
+
+func (m *StatusResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	l = len(m.Version)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.DbSize != 0 {
+		n += 1 + sovRpc(uint64(m.DbSize))
+	}
+	if m.Leader != 0 {
+		n += 1 + sovRpc(uint64(m.Leader))
+	}
+	if m.RaftIndex != 0 {
+		n += 1 + sovRpc(uint64(m.RaftIndex))
+	}
+	if m.RaftTerm != 0 {
+		n += 1 + sovRpc(uint64(m.RaftTerm))
+	}
+	return n
+}
+
+func (m *AuthEnableRequest) Size() (n int) {
+	var l int
+	_ = l
+	return n
+}
+
+func (m *AuthDisableRequest) Size() (n int) {
+	var l int
+	_ = l
+	return n
+}
+
+func (m *AuthenticateRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	l = len(m.Password)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthUserAddRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	l = len(m.Password)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthUserGetRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthUserDeleteRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthUserChangePasswordRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	l = len(m.Password)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthUserGrantRoleRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.User)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	l = len(m.Role)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthUserRevokeRoleRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	l = len(m.Role)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthRoleAddRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthRoleGetRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Role)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthUserListRequest) Size() (n int) {
+	var l int
+	_ = l
+	return n
+}
+
+func (m *AuthRoleListRequest) Size() (n int) {
+	var l int
+	_ = l
+	return n
+}
+
+func (m *AuthRoleDeleteRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Role)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthRoleGrantPermissionRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Name)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if m.Perm != nil {
+		l = m.Perm.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthRoleRevokePermissionRequest) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Role)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	l = len(m.RangeEnd)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthEnableResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthDisableResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthenticateResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	l = len(m.Token)
+	if l > 0 {
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthUserAddResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthUserGetResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if len(m.Roles) > 0 {
+		for _, s := range m.Roles {
+			l = len(s)
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *AuthUserDeleteResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthUserChangePasswordResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthUserGrantRoleResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthUserRevokeRoleResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthRoleAddResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthRoleGetResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if len(m.Perm) > 0 {
+		for _, e := range m.Perm {
+			l = e.Size()
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *AuthRoleListResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if len(m.Roles) > 0 {
+		for _, s := range m.Roles {
+			l = len(s)
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *AuthUserListResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	if len(m.Users) > 0 {
+		for _, s := range m.Users {
+			l = len(s)
+			n += 1 + l + sovRpc(uint64(l))
+		}
+	}
+	return n
+}
+
+func (m *AuthRoleDeleteResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthRoleGrantPermissionResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func (m *AuthRoleRevokePermissionResponse) Size() (n int) {
+	var l int
+	_ = l
+	if m.Header != nil {
+		l = m.Header.Size()
+		n += 1 + l + sovRpc(uint64(l))
+	}
+	return n
+}
+
+func sovRpc(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozRpc(x uint64) (n int) {
+	return sovRpc(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *ResponseHeader) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ResponseHeader: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ResponseHeader: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ClusterId", wireType)
+			}
+			m.ClusterId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ClusterId |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MemberId", wireType)
+			}
+			m.MemberId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MemberId |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
+			}
+			m.Revision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Revision |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RaftTerm", wireType)
+			}
+			m.RaftTerm = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.RaftTerm |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *RangeRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: RangeRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: RangeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
+			if m.Key == nil {
+				m.Key = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.RangeEnd = append(m.RangeEnd[:0], dAtA[iNdEx:postIndex]...)
+			if m.RangeEnd == nil {
+				m.RangeEnd = []byte{}
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Limit", wireType)
+			}
+			m.Limit = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Limit |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
+			}
+			m.Revision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Revision |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SortOrder", wireType)
+			}
+			m.SortOrder = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.SortOrder |= (RangeRequest_SortOrder(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field SortTarget", wireType)
+			}
+			m.SortTarget = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.SortTarget |= (RangeRequest_SortTarget(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 7:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Serializable", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Serializable = bool(v != 0)
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field KeysOnly", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.KeysOnly = bool(v != 0)
+		case 9:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CountOnly", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.CountOnly = bool(v != 0)
+		case 10:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MinModRevision", wireType)
+			}
+			m.MinModRevision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MinModRevision |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 11:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxModRevision", wireType)
+			}
+			m.MaxModRevision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MaxModRevision |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 12:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MinCreateRevision", wireType)
+			}
+			m.MinCreateRevision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MinCreateRevision |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 13:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MaxCreateRevision", wireType)
+			}
+			m.MaxCreateRevision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MaxCreateRevision |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *RangeResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: RangeResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: RangeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Kvs", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Kvs = append(m.Kvs, &mvccpb.KeyValue{})
+			if err := m.Kvs[len(m.Kvs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field More", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.More = bool(v != 0)
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Count", wireType)
+			}
+			m.Count = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Count |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *PutRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: PutRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: PutRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
+			if m.Key == nil {
+				m.Key = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
+			if m.Value == nil {
+				m.Value = []byte{}
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Lease", wireType)
+			}
+			m.Lease = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Lease |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PrevKv", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.PrevKv = bool(v != 0)
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreValue", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.IgnoreValue = bool(v != 0)
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field IgnoreLease", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.IgnoreLease = bool(v != 0)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *PutResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: PutResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: PutResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PrevKv", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.PrevKv == nil {
+				m.PrevKv = &mvccpb.KeyValue{}
+			}
+			if err := m.PrevKv.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DeleteRangeRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: DeleteRangeRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DeleteRangeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
+			if m.Key == nil {
+				m.Key = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.RangeEnd = append(m.RangeEnd[:0], dAtA[iNdEx:postIndex]...)
+			if m.RangeEnd == nil {
+				m.RangeEnd = []byte{}
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PrevKv", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.PrevKv = bool(v != 0)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DeleteRangeResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: DeleteRangeResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DeleteRangeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Deleted", wireType)
+			}
+			m.Deleted = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Deleted |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PrevKvs", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PrevKvs = append(m.PrevKvs, &mvccpb.KeyValue{})
+			if err := m.PrevKvs[len(m.PrevKvs)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *RequestOp) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: RequestOp: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: RequestOp: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RequestRange", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &RangeRequest{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Request = &RequestOp_RequestRange{v}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RequestPut", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &PutRequest{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Request = &RequestOp_RequestPut{v}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RequestDeleteRange", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &DeleteRangeRequest{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Request = &RequestOp_RequestDeleteRange{v}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RequestTxn", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &TxnRequest{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Request = &RequestOp_RequestTxn{v}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *ResponseOp) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: ResponseOp: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: ResponseOp: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ResponseRange", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &RangeResponse{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Response = &ResponseOp_ResponseRange{v}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ResponsePut", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &PutResponse{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Response = &ResponseOp_ResponsePut{v}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ResponseDeleteRange", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &DeleteRangeResponse{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Response = &ResponseOp_ResponseDeleteRange{v}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ResponseTxn", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &TxnResponse{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.Response = &ResponseOp_ResponseTxn{v}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Compare) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Compare: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Compare: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Result", wireType)
+			}
+			m.Result = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Result |= (Compare_CompareResult(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Target", wireType)
+			}
+			m.Target = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Target |= (Compare_CompareTarget(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
+			if m.Key == nil {
+				m.Key = []byte{}
+			}
+			iNdEx = postIndex
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
+			}
+			var v int64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.TargetUnion = &Compare_Version{v}
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreateRevision", wireType)
+			}
+			var v int64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.TargetUnion = &Compare_CreateRevision{v}
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ModRevision", wireType)
+			}
+			var v int64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.TargetUnion = &Compare_ModRevision{v}
+		case 7:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := make([]byte, postIndex-iNdEx)
+			copy(v, dAtA[iNdEx:postIndex])
+			m.TargetUnion = &Compare_Value{v}
+			iNdEx = postIndex
+		case 8:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Lease", wireType)
+			}
+			var v int64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.TargetUnion = &Compare_Lease{v}
+		case 64:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.RangeEnd = append(m.RangeEnd[:0], dAtA[iNdEx:postIndex]...)
+			if m.RangeEnd == nil {
+				m.RangeEnd = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *TxnRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: TxnRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TxnRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Compare", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Compare = append(m.Compare, &Compare{})
+			if err := m.Compare[len(m.Compare)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Success", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Success = append(m.Success, &RequestOp{})
+			if err := m.Success[len(m.Success)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Failure", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Failure = append(m.Failure, &RequestOp{})
+			if err := m.Failure[len(m.Failure)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *TxnResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: TxnResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: TxnResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Succeeded", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Succeeded = bool(v != 0)
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Responses", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Responses = append(m.Responses, &ResponseOp{})
+			if err := m.Responses[len(m.Responses)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *CompactionRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: CompactionRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: CompactionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
+			}
+			m.Revision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Revision |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Physical", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Physical = bool(v != 0)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *CompactionResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: CompactionResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: CompactionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *HashRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: HashRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: HashRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *HashKVRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: HashKVRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: HashKVRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Revision", wireType)
+			}
+			m.Revision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Revision |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *HashKVResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: HashKVResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: HashKVResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
+			}
+			m.Hash = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Hash |= (uint32(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CompactRevision", wireType)
+			}
+			m.CompactRevision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CompactRevision |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *HashResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: HashResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: HashResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Hash", wireType)
+			}
+			m.Hash = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Hash |= (uint32(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *SnapshotRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: SnapshotRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: SnapshotRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *SnapshotResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: SnapshotResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: SnapshotResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RemainingBytes", wireType)
+			}
+			m.RemainingBytes = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.RemainingBytes |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Blob", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Blob = append(m.Blob[:0], dAtA[iNdEx:postIndex]...)
+			if m.Blob == nil {
+				m.Blob = []byte{}
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *WatchRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: WatchRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: WatchRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreateRequest", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &WatchCreateRequest{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.RequestUnion = &WatchRequest_CreateRequest{v}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CancelRequest", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			v := &WatchCancelRequest{}
+			if err := v.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			m.RequestUnion = &WatchRequest_CancelRequest{v}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *WatchCreateRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: WatchCreateRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: WatchCreateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
+			if m.Key == nil {
+				m.Key = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.RangeEnd = append(m.RangeEnd[:0], dAtA[iNdEx:postIndex]...)
+			if m.RangeEnd == nil {
+				m.RangeEnd = []byte{}
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field StartRevision", wireType)
+			}
+			m.StartRevision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.StartRevision |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ProgressNotify", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.ProgressNotify = bool(v != 0)
+		case 5:
+			if wireType == 0 {
+				var v WatchCreateRequest_FilterType
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowRpc
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					v |= (WatchCreateRequest_FilterType(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				m.Filters = append(m.Filters, v)
+			} else if wireType == 2 {
+				var packedLen int
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return ErrIntOverflowRpc
+					}
+					if iNdEx >= l {
+						return io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					packedLen |= (int(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				if packedLen < 0 {
+					return ErrInvalidLengthRpc
+				}
+				postIndex := iNdEx + packedLen
+				if postIndex > l {
+					return io.ErrUnexpectedEOF
+				}
+				for iNdEx < postIndex {
+					var v WatchCreateRequest_FilterType
+					for shift := uint(0); ; shift += 7 {
+						if shift >= 64 {
+							return ErrIntOverflowRpc
+						}
+						if iNdEx >= l {
+							return io.ErrUnexpectedEOF
+						}
+						b := dAtA[iNdEx]
+						iNdEx++
+						v |= (WatchCreateRequest_FilterType(b) & 0x7F) << shift
+						if b < 0x80 {
+							break
+						}
+					}
+					m.Filters = append(m.Filters, v)
+				}
+			} else {
+				return fmt.Errorf("proto: wrong wireType = %d for field Filters", wireType)
+			}
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PrevKv", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.PrevKv = bool(v != 0)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *WatchCancelRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: WatchCancelRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: WatchCancelRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field WatchId", wireType)
+			}
+			m.WatchId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.WatchId |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *WatchResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: WatchResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: WatchResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field WatchId", wireType)
+			}
+			m.WatchId = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.WatchId |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Created", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Created = bool(v != 0)
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Canceled", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Canceled = bool(v != 0)
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CompactRevision", wireType)
+			}
+			m.CompactRevision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CompactRevision |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 6:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CancelReason", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.CancelReason = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 11:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Events", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Events = append(m.Events, &mvccpb.Event{})
+			if err := m.Events[len(m.Events)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LeaseGrantRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LeaseGrantRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseGrantRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
+			}
+			m.TTL = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.TTL |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LeaseGrantResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LeaseGrantResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseGrantResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
+			}
+			m.TTL = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.TTL |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Error", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Error = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LeaseRevokeRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LeaseRevokeRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseRevokeRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LeaseRevokeResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LeaseRevokeResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseRevokeResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LeaseKeepAliveRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LeaseKeepAliveRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseKeepAliveRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LeaseKeepAliveResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LeaseKeepAliveResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseKeepAliveResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
+			}
+			m.TTL = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.TTL |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LeaseTimeToLiveRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LeaseTimeToLiveRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseTimeToLiveRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
+			}
+			var v int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				v |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			m.Keys = bool(v != 0)
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LeaseTimeToLiveResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LeaseTimeToLiveResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseTimeToLiveResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TTL", wireType)
+			}
+			m.TTL = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.TTL |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field GrantedTTL", wireType)
+			}
+			m.GrantedTTL = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.GrantedTTL |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Keys", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Keys = append(m.Keys, make([]byte, postIndex-iNdEx))
+			copy(m.Keys[len(m.Keys)-1], dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LeaseLeasesRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LeaseLeasesRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseLeasesRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LeaseStatus) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LeaseStatus: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseStatus: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *LeaseLeasesResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: LeaseLeasesResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: LeaseLeasesResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Leases", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Leases = append(m.Leases, &LeaseStatus{})
+			if err := m.Leases[len(m.Leases)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Member) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Member: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Member: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PeerURLs", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PeerURLs = append(m.PeerURLs, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		case 4:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ClientURLs", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.ClientURLs = append(m.ClientURLs, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MemberAddRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MemberAddRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MemberAddRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PeerURLs", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PeerURLs = append(m.PeerURLs, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MemberAddResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MemberAddResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MemberAddResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Member", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Member == nil {
+				m.Member = &Member{}
+			}
+			if err := m.Member.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Members = append(m.Members, &Member{})
+			if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MemberRemoveRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MemberRemoveRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MemberRemoveRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MemberRemoveResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MemberRemoveResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MemberRemoveResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Members = append(m.Members, &Member{})
+			if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MemberUpdateRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MemberUpdateRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MemberUpdateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ID", wireType)
+			}
+			m.ID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ID |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PeerURLs", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.PeerURLs = append(m.PeerURLs, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MemberUpdateResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MemberUpdateResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MemberUpdateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Members = append(m.Members, &Member{})
+			if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MemberListRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MemberListRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MemberListRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MemberListResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MemberListResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MemberListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Members", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Members = append(m.Members, &Member{})
+			if err := m.Members[len(m.Members)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DefragmentRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: DefragmentRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DefragmentRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *DefragmentResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: DefragmentResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: DefragmentResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MoveLeaderRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MoveLeaderRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MoveLeaderRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field TargetID", wireType)
+			}
+			m.TargetID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.TargetID |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *MoveLeaderResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: MoveLeaderResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: MoveLeaderResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AlarmRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AlarmRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AlarmRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Action", wireType)
+			}
+			m.Action = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Action |= (AlarmRequest_AlarmAction(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MemberID", wireType)
+			}
+			m.MemberID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MemberID |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Alarm", wireType)
+			}
+			m.Alarm = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Alarm |= (AlarmType(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AlarmMember) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AlarmMember: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AlarmMember: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field MemberID", wireType)
+			}
+			m.MemberID = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.MemberID |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Alarm", wireType)
+			}
+			m.Alarm = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Alarm |= (AlarmType(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AlarmResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AlarmResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AlarmResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Alarms", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Alarms = append(m.Alarms, &AlarmMember{})
+			if err := m.Alarms[len(m.Alarms)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *StatusRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: StatusRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: StatusRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *StatusResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: StatusResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: StatusResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Version = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field DbSize", wireType)
+			}
+			m.DbSize = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.DbSize |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Leader", wireType)
+			}
+			m.Leader = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Leader |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RaftIndex", wireType)
+			}
+			m.RaftIndex = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.RaftIndex |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RaftTerm", wireType)
+			}
+			m.RaftTerm = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.RaftTerm |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthEnableRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthEnableRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthEnableRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthDisableRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthDisableRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthDisableRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthenticateRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthenticateRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthenticateRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Password = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthUserAddRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthUserAddRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthUserAddRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Password = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthUserGetRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthUserGetRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthUserGetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthUserDeleteRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthUserDeleteRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthUserDeleteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthUserChangePasswordRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthUserChangePasswordRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthUserChangePasswordRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Password", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Password = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthUserGrantRoleRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthUserGrantRoleRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthUserGrantRoleRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field User", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.User = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Role = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthUserRevokeRoleRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthUserRevokeRoleRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthUserRevokeRoleRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Role = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthRoleAddRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthRoleAddRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthRoleAddRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthRoleGetRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthRoleGetRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthRoleGetRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Role = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthUserListRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthUserListRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthUserListRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthRoleListRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthRoleListRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthRoleListRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthRoleDeleteRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthRoleDeleteRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthRoleDeleteRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Role = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthRoleGrantPermissionRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthRoleGrantPermissionRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthRoleGrantPermissionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Name", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Name = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Perm", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Perm == nil {
+				m.Perm = &authpb.Permission{}
+			}
+			if err := m.Perm.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthRoleRevokePermissionRequest) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthRoleRevokePermissionRequest: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthRoleRevokePermissionRequest: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Role", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Role = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Key = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field RangeEnd", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.RangeEnd = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthEnableResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthEnableResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthEnableResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthDisableResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthDisableResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthDisableResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthenticateResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthenticateResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthenticateResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Token", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Token = string(dAtA[iNdEx:postIndex])
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthUserAddResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthUserAddResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthUserAddResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthUserGetResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthUserGetResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthUserGetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthUserDeleteResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthUserDeleteResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthUserDeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthUserChangePasswordResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthUserChangePasswordResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthUserChangePasswordResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthUserGrantRoleResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthUserGrantRoleResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthUserGrantRoleResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthUserRevokeRoleResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthUserRevokeRoleResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthUserRevokeRoleResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthRoleAddResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthRoleAddResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthRoleAddResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthRoleGetResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthRoleGetResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthRoleGetResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Perm", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Perm = append(m.Perm, &authpb.Permission{})
+			if err := m.Perm[len(m.Perm)-1].Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthRoleListResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthRoleListResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthRoleListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Roles", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Roles = append(m.Roles, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthUserListResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthUserListResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthUserListResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Users", wireType)
+			}
+			var stringLen uint64
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				stringLen |= (uint64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			intStringLen := int(stringLen)
+			if intStringLen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + intStringLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Users = append(m.Users, string(dAtA[iNdEx:postIndex]))
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthRoleDeleteResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthRoleDeleteResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthRoleDeleteResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthRoleGrantPermissionResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthRoleGrantPermissionResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthRoleGrantPermissionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *AuthRoleRevokePermissionResponse) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: AuthRoleRevokePermissionResponse: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: AuthRoleRevokePermissionResponse: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Header", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthRpc
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Header == nil {
+				m.Header = &ResponseHeader{}
+			}
+			if err := m.Header.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipRpc(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthRpc
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipRpc(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowRpc
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowRpc
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			iNdEx += length
+			if length < 0 {
+				return 0, ErrInvalidLengthRpc
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowRpc
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipRpc(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthRpc = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowRpc   = fmt.Errorf("proto: integer overflow")
+)
+
+func init() { proto.RegisterFile("rpc.proto", fileDescriptorRpc) }
+
+var fileDescriptorRpc = []byte{
+	// 3674 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xbc, 0x5b, 0x5b, 0x6f, 0x1b, 0xc7,
+	0x77, 0xd7, 0x92, 0x22, 0x29, 0x1e, 0x5e, 0x44, 0x8d, 0x64, 0x9b, 0xa2, 0x6d, 0x59, 0x1e, 0xdf,
+	0x64, 0x3b, 0x16, 0xff, 0x7f, 0x25, 0xed, 0x83, 0x5b, 0x04, 0x91, 0x25, 0xc6, 0x52, 0x24, 0x4b,
+	0xca, 0x8a, 0x56, 0x52, 0x20, 0x28, 0xb1, 0x22, 0xc7, 0xd2, 0x42, 0xe4, 0x2e, 0xb3, 0xbb, 0xa4,
+	0xa5, 0x34, 0x2d, 0x8a, 0x20, 0x41, 0xd1, 0x02, 0x7d, 0x69, 0x1e, 0x7a, 0x7b, 0x2c, 0x8a, 0x22,
+	0x2f, 0x7d, 0x2b, 0xfa, 0x15, 0x8a, 0xbe, 0xb4, 0x40, 0xbf, 0x40, 0x91, 0xf6, 0xa5, 0xdf, 0xa1,
+	0x45, 0xff, 0x98, 0xdb, 0xee, 0xec, 0x72, 0x97, 0x52, 0xc2, 0x24, 0x2f, 0xf2, 0xce, 0x99, 0x33,
+	0xe7, 0x9c, 0x39, 0x33, 0xe7, 0x9c, 0x99, 0xdf, 0xd0, 0x90, 0x77, 0xfa, 0xed, 0xd5, 0xbe, 0x63,
+	0x7b, 0x36, 0x2a, 0x12, 0xaf, 0xdd, 0x71, 0x89, 0x33, 0x24, 0x4e, 0xff, 0xb8, 0xb6, 0x70, 0x62,
+	0x9f, 0xd8, 0xac, 0xa3, 0x4e, 0xbf, 0x38, 0x4f, 0x6d, 0x91, 0xf2, 0xd4, 0x7b, 0xc3, 0x76, 0x9b,
+	0xfd, 0xe9, 0x1f, 0xd7, 0xcf, 0x86, 0xa2, 0xeb, 0x26, 0xeb, 0x32, 0x06, 0xde, 0x29, 0xfb, 0xd3,
+	0x3f, 0x66, 0xff, 0x88, 0xce, 0x5b, 0x27, 0xb6, 0x7d, 0xd2, 0x25, 0x75, 0xa3, 0x6f, 0xd6, 0x0d,
+	0xcb, 0xb2, 0x3d, 0xc3, 0x33, 0x6d, 0xcb, 0xe5, 0xbd, 0xf8, 0x1b, 0x0d, 0xca, 0x3a, 0x71, 0xfb,
+	0xb6, 0xe5, 0x92, 0x2d, 0x62, 0x74, 0x88, 0x83, 0x6e, 0x03, 0xb4, 0xbb, 0x03, 0xd7, 0x23, 0x4e,
+	0xcb, 0xec, 0x54, 0xb5, 0x65, 0x6d, 0x65, 0x5a, 0xcf, 0x0b, 0xca, 0x76, 0x07, 0xdd, 0x84, 0x7c,
+	0x8f, 0xf4, 0x8e, 0x79, 0x6f, 0x8a, 0xf5, 0xce, 0x70, 0xc2, 0x76, 0x07, 0xd5, 0x60, 0xc6, 0x21,
+	0x43, 0xd3, 0x35, 0x6d, 0xab, 0x9a, 0x5e, 0xd6, 0x56, 0xd2, 0xba, 0xdf, 0xa6, 0x03, 0x1d, 0xe3,
+	0x8d, 0xd7, 0xf2, 0x88, 0xd3, 0xab, 0x4e, 0xf3, 0x81, 0x94, 0xd0, 0x24, 0x4e, 0x0f, 0x7f, 0x9d,
+	0x81, 0xa2, 0x6e, 0x58, 0x27, 0x44, 0x27, 0x9f, 0x0f, 0x88, 0xeb, 0xa1, 0x0a, 0xa4, 0xcf, 0xc8,
+	0x05, 0x53, 0x5f, 0xd4, 0xe9, 0x27, 0x1f, 0x6f, 0x9d, 0x90, 0x16, 0xb1, 0xb8, 0xe2, 0x22, 0x1d,
+	0x6f, 0x9d, 0x90, 0x86, 0xd5, 0x41, 0x0b, 0x90, 0xe9, 0x9a, 0x3d, 0xd3, 0x13, 0x5a, 0x79, 0x23,
+	0x64, 0xce, 0x74, 0xc4, 0x9c, 0x0d, 0x00, 0xd7, 0x76, 0xbc, 0x96, 0xed, 0x74, 0x88, 0x53, 0xcd,
+	0x2c, 0x6b, 0x2b, 0xe5, 0xb5, 0xfb, 0xab, 0xea, 0x42, 0xac, 0xaa, 0x06, 0xad, 0x1e, 0xda, 0x8e,
+	0xb7, 0x4f, 0x79, 0xf5, 0xbc, 0x2b, 0x3f, 0xd1, 0x87, 0x50, 0x60, 0x42, 0x3c, 0xc3, 0x39, 0x21,
+	0x5e, 0x35, 0xcb, 0xa4, 0x3c, 0xb8, 0x44, 0x4a, 0x93, 0x31, 0xeb, 0x4c, 0x3d, 0xff, 0x46, 0x18,
+	0x8a, 0x2e, 0x71, 0x4c, 0xa3, 0x6b, 0x7e, 0x61, 0x1c, 0x77, 0x49, 0x35, 0xb7, 0xac, 0xad, 0xcc,
+	0xe8, 0x21, 0x1a, 0x9d, 0xff, 0x19, 0xb9, 0x70, 0x5b, 0xb6, 0xd5, 0xbd, 0xa8, 0xce, 0x30, 0x86,
+	0x19, 0x4a, 0xd8, 0xb7, 0xba, 0x17, 0x6c, 0xd1, 0xec, 0x81, 0xe5, 0xf1, 0xde, 0x3c, 0xeb, 0xcd,
+	0x33, 0x0a, 0xeb, 0x5e, 0x81, 0x4a, 0xcf, 0xb4, 0x5a, 0x3d, 0xbb, 0xd3, 0xf2, 0x1d, 0x02, 0xcc,
+	0x21, 0xe5, 0x9e, 0x69, 0xbd, 0xb2, 0x3b, 0xba, 0x74, 0x0b, 0xe5, 0x34, 0xce, 0xc3, 0x9c, 0x05,
+	0xc1, 0x69, 0x9c, 0xab, 0x9c, 0xab, 0x30, 0x4f, 0x65, 0xb6, 0x1d, 0x62, 0x78, 0x24, 0x60, 0x2e,
+	0x32, 0xe6, 0xb9, 0x9e, 0x69, 0x6d, 0xb0, 0x9e, 0x10, 0xbf, 0x71, 0x3e, 0xc2, 0x5f, 0x12, 0xfc,
+	0xc6, 0x79, 0x98, 0x1f, 0xaf, 0x42, 0xde, 0xf7, 0x39, 0x9a, 0x81, 0xe9, 0xbd, 0xfd, 0xbd, 0x46,
+	0x65, 0x0a, 0x01, 0x64, 0xd7, 0x0f, 0x37, 0x1a, 0x7b, 0x9b, 0x15, 0x0d, 0x15, 0x20, 0xb7, 0xd9,
+	0xe0, 0x8d, 0x14, 0x7e, 0x01, 0x10, 0x78, 0x17, 0xe5, 0x20, 0xbd, 0xd3, 0xf8, 0xbd, 0xca, 0x14,
+	0xe5, 0x39, 0x6a, 0xe8, 0x87, 0xdb, 0xfb, 0x7b, 0x15, 0x8d, 0x0e, 0xde, 0xd0, 0x1b, 0xeb, 0xcd,
+	0x46, 0x25, 0x45, 0x39, 0x5e, 0xed, 0x6f, 0x56, 0xd2, 0x28, 0x0f, 0x99, 0xa3, 0xf5, 0xdd, 0xd7,
+	0x8d, 0xca, 0x34, 0xfe, 0x56, 0x83, 0x92, 0x58, 0x2f, 0x1e, 0x13, 0xe8, 0x3d, 0xc8, 0x9e, 0xb2,
+	0xb8, 0x60, 0x5b, 0xb1, 0xb0, 0x76, 0x2b, 0xb2, 0xb8, 0xa1, 0xd8, 0xd1, 0x05, 0x2f, 0xc2, 0x90,
+	0x3e, 0x1b, 0xba, 0xd5, 0xd4, 0x72, 0x7a, 0xa5, 0xb0, 0x56, 0x59, 0xe5, 0x01, 0xbb, 0xba, 0x43,
+	0x2e, 0x8e, 0x8c, 0xee, 0x80, 0xe8, 0xb4, 0x13, 0x21, 0x98, 0xee, 0xd9, 0x0e, 0x61, 0x3b, 0x76,
+	0x46, 0x67, 0xdf, 0x74, 0x1b, 0xb3, 0x45, 0x13, 0xbb, 0x95, 0x37, 0xf0, 0x77, 0x1a, 0xc0, 0xc1,
+	0xc0, 0x4b, 0x0e, 0x8d, 0x05, 0xc8, 0x0c, 0xa9, 0x60, 0x11, 0x16, 0xbc, 0xc1, 0x62, 0x82, 0x18,
+	0x2e, 0xf1, 0x63, 0x82, 0x36, 0xd0, 0x0d, 0xc8, 0xf5, 0x1d, 0x32, 0x6c, 0x9d, 0x0d, 0x99, 0x92,
+	0x19, 0x3d, 0x4b, 0x9b, 0x3b, 0x43, 0x74, 0x17, 0x8a, 0xe6, 0x89, 0x65, 0x3b, 0xa4, 0xc5, 0x65,
+	0x65, 0x58, 0x6f, 0x81, 0xd3, 0x98, 0xdd, 0x0a, 0x0b, 0x17, 0x9c, 0x55, 0x59, 0x76, 0x29, 0x09,
+	0x5b, 0x50, 0x60, 0xa6, 0x4e, 0xe4, 0xbe, 0xc7, 0x81, 0x8d, 0x29, 0x36, 0x6c, 0xd4, 0x85, 0xc2,
+	0x6a, 0xfc, 0x19, 0xa0, 0x4d, 0xd2, 0x25, 0x1e, 0x99, 0x24, 0x7b, 0x28, 0x3e, 0x49, 0xab, 0x3e,
+	0xc1, 0x7f, 0xa1, 0xc1, 0x7c, 0x48, 0xfc, 0x44, 0xd3, 0xaa, 0x42, 0xae, 0xc3, 0x84, 0x71, 0x0b,
+	0xd2, 0xba, 0x6c, 0xa2, 0xa7, 0x30, 0x23, 0x0c, 0x70, 0xab, 0xe9, 0x84, 0x4d, 0x93, 0xe3, 0x36,
+	0xb9, 0xf8, 0xbb, 0x14, 0xe4, 0xc5, 0x44, 0xf7, 0xfb, 0x68, 0x1d, 0x4a, 0x0e, 0x6f, 0xb4, 0xd8,
+	0x7c, 0x84, 0x45, 0xb5, 0xe4, 0x24, 0xb4, 0x35, 0xa5, 0x17, 0xc5, 0x10, 0x46, 0x46, 0xbf, 0x03,
+	0x05, 0x29, 0xa2, 0x3f, 0xf0, 0x84, 0xcb, 0xab, 0x61, 0x01, 0xc1, 0xfe, 0xdb, 0x9a, 0xd2, 0x41,
+	0xb0, 0x1f, 0x0c, 0x3c, 0xd4, 0x84, 0x05, 0x39, 0x98, 0xcf, 0x46, 0x98, 0x91, 0x66, 0x52, 0x96,
+	0xc3, 0x52, 0x46, 0x97, 0x6a, 0x6b, 0x4a, 0x47, 0x62, 0xbc, 0xd2, 0xa9, 0x9a, 0xe4, 0x9d, 0xf3,
+	0xe4, 0x3d, 0x62, 0x52, 0xf3, 0xdc, 0x1a, 0x35, 0xa9, 0x79, 0x6e, 0xbd, 0xc8, 0x43, 0x4e, 0xb4,
+	0xf0, 0x3f, 0xa7, 0x00, 0xe4, 0x6a, 0xec, 0xf7, 0xd1, 0x26, 0x94, 0x1d, 0xd1, 0x0a, 0x79, 0xeb,
+	0x66, 0xac, 0xb7, 0xc4, 0x22, 0x4e, 0xe9, 0x25, 0x39, 0x88, 0x1b, 0xf7, 0x3e, 0x14, 0x7d, 0x29,
+	0x81, 0xc3, 0x16, 0x63, 0x1c, 0xe6, 0x4b, 0x28, 0xc8, 0x01, 0xd4, 0x65, 0x9f, 0xc0, 0x35, 0x7f,
+	0x7c, 0x8c, 0xcf, 0xee, 0x8e, 0xf1, 0x99, 0x2f, 0x70, 0x5e, 0x4a, 0x50, 0xbd, 0xa6, 0x1a, 0x16,
+	0xb8, 0x6d, 0x31, 0xc6, 0x6d, 0xa3, 0x86, 0x51, 0xc7, 0x01, 0xad, 0x97, 0xbc, 0x89, 0xff, 0x27,
+	0x0d, 0xb9, 0x0d, 0xbb, 0xd7, 0x37, 0x1c, 0xba, 0x1a, 0x59, 0x87, 0xb8, 0x83, 0xae, 0xc7, 0xdc,
+	0x55, 0x5e, 0xbb, 0x17, 0x96, 0x28, 0xd8, 0xe4, 0xbf, 0x3a, 0x63, 0xd5, 0xc5, 0x10, 0x3a, 0x58,
+	0x94, 0xc7, 0xd4, 0x15, 0x06, 0x8b, 0xe2, 0x28, 0x86, 0xc8, 0x40, 0x4e, 0x07, 0x81, 0x5c, 0x83,
+	0xdc, 0x90, 0x38, 0x41, 0x49, 0xdf, 0x9a, 0xd2, 0x25, 0x01, 0x3d, 0x86, 0xd9, 0x68, 0x79, 0xc9,
+	0x08, 0x9e, 0x72, 0x3b, 0x5c, 0x8d, 0xee, 0x41, 0x31, 0x54, 0xe3, 0xb2, 0x82, 0xaf, 0xd0, 0x53,
+	0x4a, 0xdc, 0x75, 0x99, 0x57, 0x69, 0x3d, 0x2e, 0x6e, 0x4d, 0xc9, 0xcc, 0x7a, 0x5d, 0x66, 0xd6,
+	0x19, 0x31, 0x4a, 0xe4, 0xd6, 0x50, 0x92, 0xf9, 0x20, 0x9c, 0x64, 0xf0, 0x07, 0x50, 0x0a, 0x39,
+	0x88, 0xd6, 0x9d, 0xc6, 0xc7, 0xaf, 0xd7, 0x77, 0x79, 0x91, 0x7a, 0xc9, 0xea, 0x92, 0x5e, 0xd1,
+	0x68, 0xad, 0xdb, 0x6d, 0x1c, 0x1e, 0x56, 0x52, 0xa8, 0x04, 0xf9, 0xbd, 0xfd, 0x66, 0x8b, 0x73,
+	0xa5, 0xf1, 0x4b, 0x5f, 0x82, 0x28, 0x72, 0x4a, 0x6d, 0x9b, 0x52, 0x6a, 0x9b, 0x26, 0x6b, 0x5b,
+	0x2a, 0xa8, 0x6d, 0xac, 0xcc, 0xed, 0x36, 0xd6, 0x0f, 0x1b, 0x95, 0xe9, 0x17, 0x65, 0x28, 0x72,
+	0xff, 0xb6, 0x06, 0x16, 0x2d, 0xb5, 0x7f, 0xa7, 0x01, 0x04, 0xd1, 0x84, 0xea, 0x90, 0x6b, 0x73,
+	0x3d, 0x55, 0x8d, 0x25, 0xa3, 0x6b, 0xb1, 0x4b, 0xa6, 0x4b, 0x2e, 0xf4, 0x6b, 0xc8, 0xb9, 0x83,
+	0x76, 0x9b, 0xb8, 0xb2, 0xe4, 0xdd, 0x88, 0xe6, 0x43, 0x91, 0xad, 0x74, 0xc9, 0x47, 0x87, 0xbc,
+	0x31, 0xcc, 0xee, 0x80, 0x15, 0xc0, 0xf1, 0x43, 0x04, 0x1f, 0xfe, 0x6b, 0x0d, 0x0a, 0xca, 0xe6,
+	0xfd, 0x91, 0x49, 0xf8, 0x16, 0xe4, 0x99, 0x0d, 0xa4, 0x23, 0xd2, 0xf0, 0x8c, 0x1e, 0x10, 0xd0,
+	0x6f, 0x43, 0x5e, 0x46, 0x80, 0xcc, 0xc4, 0xd5, 0x78, 0xb1, 0xfb, 0x7d, 0x3d, 0x60, 0xc5, 0x3b,
+	0x30, 0xc7, 0xbc, 0xd2, 0xa6, 0x87, 0x6b, 0xe9, 0x47, 0xf5, 0xf8, 0xa9, 0x45, 0x8e, 0x9f, 0x35,
+	0x98, 0xe9, 0x9f, 0x5e, 0xb8, 0x66, 0xdb, 0xe8, 0x0a, 0x2b, 0xfc, 0x36, 0xfe, 0x08, 0x90, 0x2a,
+	0x6c, 0x92, 0xe9, 0xe2, 0x12, 0x14, 0xb6, 0x0c, 0xf7, 0x54, 0x98, 0x84, 0x9f, 0x42, 0x89, 0x36,
+	0x77, 0x8e, 0xae, 0x60, 0x23, 0xbb, 0x1c, 0x48, 0xee, 0x89, 0x7c, 0x8e, 0x60, 0xfa, 0xd4, 0x70,
+	0x4f, 0xd9, 0x44, 0x4b, 0x3a, 0xfb, 0x46, 0x8f, 0xa1, 0xd2, 0xe6, 0x93, 0x6c, 0x45, 0xae, 0x0c,
+	0xb3, 0x82, 0xee, 0x9f, 0x04, 0x3f, 0x85, 0x22, 0x9f, 0xc3, 0x4f, 0x6d, 0x04, 0x9e, 0x83, 0xd9,
+	0x43, 0xcb, 0xe8, 0xbb, 0xa7, 0xb6, 0xac, 0x6e, 0x74, 0xd2, 0x95, 0x80, 0x36, 0x91, 0xc6, 0x47,
+	0x30, 0xeb, 0x90, 0x9e, 0x61, 0x5a, 0xa6, 0x75, 0xd2, 0x3a, 0xbe, 0xf0, 0x88, 0x2b, 0x2e, 0x4c,
+	0x65, 0x9f, 0xfc, 0x82, 0x52, 0xa9, 0x69, 0xc7, 0x5d, 0xfb, 0x58, 0xa4, 0x39, 0xf6, 0x8d, 0xff,
+	0x49, 0x83, 0xe2, 0x27, 0x86, 0xd7, 0x96, 0x4b, 0x87, 0xb6, 0xa1, 0xec, 0x27, 0x37, 0x46, 0x11,
+	0xb6, 0x44, 0x4a, 0x2c, 0x1b, 0x23, 0x8f, 0xd2, 0xb2, 0x3a, 0x96, 0xda, 0x2a, 0x81, 0x89, 0x32,
+	0xac, 0x36, 0xe9, 0xfa, 0xa2, 0x52, 0xc9, 0xa2, 0x18, 0xa3, 0x2a, 0x4a, 0x25, 0xbc, 0x98, 0x0d,
+	0x8e, 0x1f, 0x3c, 0x97, 0xfc, 0x4d, 0x0a, 0xd0, 0xa8, 0x0d, 0x3f, 0xf4, 0x44, 0xf6, 0x00, 0xca,
+	0xae, 0x67, 0x38, 0x23, 0x7b, 0xa3, 0xc4, 0xa8, 0x7e, 0x82, 0x7e, 0x04, 0xb3, 0x7d, 0xc7, 0x3e,
+	0x71, 0x88, 0xeb, 0xb6, 0x2c, 0xdb, 0x33, 0xdf, 0x5c, 0x88, 0x43, 0x6d, 0x59, 0x92, 0xf7, 0x18,
+	0x15, 0x35, 0x20, 0xf7, 0xc6, 0xec, 0x7a, 0xc4, 0x71, 0xab, 0x99, 0xe5, 0xf4, 0x4a, 0x79, 0xed,
+	0xe9, 0x65, 0x5e, 0x5b, 0xfd, 0x90, 0xf1, 0x37, 0x2f, 0xfa, 0x44, 0x97, 0x63, 0xd5, 0x83, 0x62,
+	0x36, 0x74, 0x50, 0x7c, 0x00, 0x10, 0xf0, 0xd3, 0x54, 0xbb, 0xb7, 0x7f, 0xf0, 0xba, 0x59, 0x99,
+	0x42, 0x45, 0x98, 0xd9, 0xdb, 0xdf, 0x6c, 0xec, 0x36, 0x68, 0x5e, 0xc6, 0x75, 0xe9, 0x1b, 0xd5,
+	0x87, 0x68, 0x11, 0x66, 0xde, 0x52, 0xaa, 0xbc, 0x6f, 0xa7, 0xf5, 0x1c, 0x6b, 0x6f, 0x77, 0xf0,
+	0x9f, 0xa7, 0xa0, 0x24, 0x76, 0xc1, 0x44, 0x5b, 0x51, 0x55, 0x91, 0x0a, 0xa9, 0xa0, 0xa7, 0x52,
+	0xbe, 0x3b, 0x3a, 0xe2, 0xf0, 0x2b, 0x9b, 0x34, 0x37, 0xf0, 0xc5, 0x26, 0x1d, 0xe1, 0x56, 0xbf,
+	0x1d, 0x1b, 0xbe, 0x99, 0xd8, 0xf0, 0x45, 0xf7, 0xa0, 0xe4, 0xef, 0x36, 0xc3, 0x15, 0xb5, 0x36,
+	0xaf, 0x17, 0xe5, 0x46, 0xa2, 0x34, 0xf4, 0x00, 0xb2, 0x64, 0x48, 0x2c, 0xcf, 0xad, 0x16, 0x58,
+	0xd6, 0x2d, 0xc9, 0xf3, 0x6f, 0x83, 0x52, 0x75, 0xd1, 0x89, 0x7f, 0x0b, 0xe6, 0xd8, 0x3d, 0xe3,
+	0xa5, 0x63, 0x58, 0xea, 0x85, 0xa8, 0xd9, 0xdc, 0x15, 0xae, 0xa3, 0x9f, 0xa8, 0x0c, 0xa9, 0xed,
+	0x4d, 0x31, 0xd1, 0xd4, 0xf6, 0x26, 0xfe, 0x4a, 0x03, 0xa4, 0x8e, 0x9b, 0xc8, 0x97, 0x11, 0xe1,
+	0x52, 0x7d, 0x3a, 0x50, 0xbf, 0x00, 0x19, 0xe2, 0x38, 0xb6, 0xc3, 0xbc, 0x96, 0xd7, 0x79, 0x03,
+	0xdf, 0x17, 0x36, 0xe8, 0x64, 0x68, 0x9f, 0xf9, 0x81, 0xc1, 0xa5, 0x69, 0xbe, 0xa9, 0x3b, 0x30,
+	0x1f, 0xe2, 0x9a, 0x28, 0xfb, 0x3f, 0x82, 0x6b, 0x4c, 0xd8, 0x0e, 0x21, 0xfd, 0xf5, 0xae, 0x39,
+	0x4c, 0xd4, 0xda, 0x87, 0xeb, 0x51, 0xc6, 0x9f, 0xd7, 0x47, 0xf8, 0x77, 0x85, 0xc6, 0xa6, 0xd9,
+	0x23, 0x4d, 0x7b, 0x37, 0xd9, 0x36, 0x9a, 0x1d, 0xcf, 0xc8, 0x85, 0x2b, 0xca, 0x24, 0xfb, 0xc6,
+	0x7f, 0xaf, 0xc1, 0x8d, 0x91, 0xe1, 0x3f, 0xf3, 0xaa, 0x2e, 0x01, 0x9c, 0xd0, 0xed, 0x43, 0x3a,
+	0xb4, 0x83, 0xdf, 0xd0, 0x15, 0x8a, 0x6f, 0x27, 0x4d, 0x30, 0x45, 0x61, 0xe7, 0x82, 0x58, 0x73,
+	0xf6, 0xc7, 0x95, 0x35, 0xe6, 0x36, 0x14, 0x18, 0xe1, 0xd0, 0x33, 0xbc, 0x81, 0x3b, 0xb2, 0x18,
+	0x7f, 0x24, 0xb6, 0x80, 0x1c, 0x34, 0xd1, 0xbc, 0x7e, 0x0d, 0x59, 0x76, 0x38, 0x95, 0x47, 0xb3,
+	0xc8, 0x6d, 0x40, 0xb1, 0x43, 0x17, 0x8c, 0xf8, 0x14, 0xb2, 0xaf, 0x18, 0xa2, 0xa7, 0x58, 0x36,
+	0x2d, 0x97, 0xc2, 0x32, 0x7a, 0x1c, 0x67, 0xc8, 0xeb, 0xec, 0x9b, 0x9d, 0x64, 0x08, 0x71, 0x5e,
+	0xeb, 0xbb, 0xfc, 0xc4, 0x94, 0xd7, 0xfd, 0x36, 0x75, 0x59, 0xbb, 0x6b, 0x12, 0xcb, 0x63, 0xbd,
+	0xd3, 0xac, 0x57, 0xa1, 0xe0, 0x55, 0xa8, 0x70, 0x4d, 0xeb, 0x9d, 0x8e, 0x72, 0x22, 0xf1, 0xe5,
+	0x69, 0x61, 0x79, 0xf8, 0x1f, 0x34, 0x98, 0x53, 0x06, 0x4c, 0xe4, 0x98, 0x77, 0x20, 0xcb, 0x71,
+	0x4b, 0x51, 0xfc, 0x16, 0xc2, 0xa3, 0xb8, 0x1a, 0x5d, 0xf0, 0xa0, 0x55, 0xc8, 0xf1, 0x2f, 0x79,
+	0x2c, 0x8c, 0x67, 0x97, 0x4c, 0xf8, 0x01, 0xcc, 0x0b, 0x12, 0xe9, 0xd9, 0x71, 0x7b, 0x9b, 0x39,
+	0x14, 0x7f, 0x09, 0x0b, 0x61, 0xb6, 0x89, 0xa6, 0xa4, 0x18, 0x99, 0xba, 0x8a, 0x91, 0xeb, 0xd2,
+	0xc8, 0xd7, 0xfd, 0x8e, 0x52, 0xab, 0xa3, 0xab, 0xae, 0xae, 0x48, 0x2a, 0xb2, 0x22, 0xfe, 0x04,
+	0xa4, 0x88, 0x5f, 0x74, 0x02, 0xf3, 0x72, 0x3b, 0xec, 0x9a, 0xae, 0x7f, 0x82, 0xfb, 0x02, 0x90,
+	0x4a, 0xfc, 0xa5, 0x0d, 0xda, 0x24, 0x6f, 0x1c, 0xe3, 0xa4, 0x47, 0xfc, 0xfa, 0x44, 0xcf, 0xf3,
+	0x2a, 0x71, 0xa2, 0x8c, 0x5e, 0x87, 0xb9, 0x57, 0xf6, 0x90, 0xa6, 0x06, 0x4a, 0x0d, 0x42, 0x86,
+	0xdf, 0xe7, 0xfc, 0x65, 0xf3, 0xdb, 0x54, 0xb9, 0x3a, 0x60, 0x22, 0xe5, 0xff, 0xa6, 0x41, 0x71,
+	0xbd, 0x6b, 0x38, 0x3d, 0xa9, 0xf8, 0x7d, 0xc8, 0xf2, 0x5b, 0x8a, 0x00, 0x06, 0x1e, 0x86, 0xc5,
+	0xa8, 0xbc, 0xbc, 0xb1, 0xce, 0xef, 0x34, 0x62, 0x14, 0x35, 0x5c, 0xbc, 0x1d, 0x6c, 0x46, 0xde,
+	0x12, 0x36, 0xd1, 0x33, 0xc8, 0x18, 0x74, 0x08, 0x4b, 0xc1, 0xe5, 0xe8, 0xfd, 0x90, 0x49, 0x63,
+	0x87, 0x33, 0xce, 0x85, 0xdf, 0x83, 0x82, 0xa2, 0x81, 0xde, 0x80, 0x5f, 0x36, 0xc4, 0x01, 0x6c,
+	0x7d, 0xa3, 0xb9, 0x7d, 0xc4, 0x2f, 0xc6, 0x65, 0x80, 0xcd, 0x86, 0xdf, 0x4e, 0xe1, 0x4f, 0xc5,
+	0x28, 0x91, 0xef, 0x54, 0x7b, 0xb4, 0x24, 0x7b, 0x52, 0x57, 0xb2, 0xe7, 0x1c, 0x4a, 0x62, 0xfa,
+	0x93, 0xa6, 0x6f, 0x26, 0x2f, 0x21, 0x7d, 0x2b, 0xc6, 0xeb, 0x82, 0x11, 0xcf, 0x42, 0x49, 0x24,
+	0x74, 0xb1, 0xff, 0xfe, 0x55, 0x83, 0xb2, 0xa4, 0x4c, 0x0a, 0x60, 0x4a, 0xec, 0x85, 0x57, 0x00,
+	0x1f, 0x79, 0xb9, 0x0e, 0xd9, 0xce, 0xf1, 0xa1, 0xf9, 0x85, 0x04, 0x9b, 0x45, 0x8b, 0xd2, 0xbb,
+	0x5c, 0x0f, 0x7f, 0xf1, 0x11, 0x2d, 0x7a, 0x0b, 0x77, 0x8c, 0x37, 0xde, 0xb6, 0xd5, 0x21, 0xe7,
+	0xec, 0xdc, 0x38, 0xad, 0x07, 0x04, 0x76, 0x29, 0x15, 0x2f, 0x43, 0xec, 0xb0, 0xa8, 0xbe, 0x14,
+	0xcd, 0xc3, 0xdc, 0xfa, 0xc0, 0x3b, 0x6d, 0x58, 0xc6, 0x71, 0x57, 0x66, 0x2c, 0x5a, 0x66, 0x29,
+	0x71, 0xd3, 0x74, 0x55, 0x6a, 0x03, 0xe6, 0x29, 0x95, 0x58, 0x9e, 0xd9, 0x56, 0xd2, 0x9b, 0x2c,
+	0x62, 0x5a, 0xa4, 0x88, 0x19, 0xae, 0xfb, 0xd6, 0x76, 0x3a, 0x62, 0x6a, 0x7e, 0x1b, 0x6f, 0x72,
+	0xe1, 0xaf, 0xdd, 0x50, 0x99, 0xfa, 0xa1, 0x52, 0x56, 0x02, 0x29, 0x2f, 0x89, 0x37, 0x46, 0x0a,
+	0x7e, 0x0a, 0xd7, 0x24, 0xa7, 0x00, 0xf7, 0xc6, 0x30, 0xef, 0xc3, 0x6d, 0xc9, 0xbc, 0x71, 0x4a,
+	0x6f, 0x4f, 0x07, 0x42, 0xe1, 0x8f, 0xb5, 0xf3, 0x05, 0x54, 0x7d, 0x3b, 0xd9, 0x61, 0xd9, 0xee,
+	0xaa, 0x06, 0x0c, 0x5c, 0xb1, 0x67, 0xf2, 0x3a, 0xfb, 0xa6, 0x34, 0xc7, 0xee, 0xfa, 0x47, 0x02,
+	0xfa, 0x8d, 0x37, 0x60, 0x51, 0xca, 0x10, 0xc7, 0xd8, 0xb0, 0x90, 0x11, 0x83, 0xe2, 0x84, 0x08,
+	0x87, 0xd1, 0xa1, 0xe3, 0xdd, 0xae, 0x72, 0x86, 0x5d, 0xcb, 0x64, 0x6a, 0x8a, 0xcc, 0x6b, 0x7c,
+	0x47, 0x50, 0xc3, 0xd4, 0x8a, 0x21, 0xc8, 0x54, 0x80, 0x4a, 0x16, 0x0b, 0x41, 0xc9, 0x23, 0x0b,
+	0x31, 0x22, 0xfa, 0x33, 0x58, 0xf2, 0x8d, 0xa0, 0x7e, 0x3b, 0x20, 0x4e, 0xcf, 0x74, 0x5d, 0x05,
+	0x0e, 0x8a, 0x9b, 0xf8, 0x43, 0x98, 0xee, 0x13, 0x91, 0x53, 0x0a, 0x6b, 0x68, 0x95, 0xbf, 0xdf,
+	0xae, 0x2a, 0x83, 0x59, 0x3f, 0xee, 0xc0, 0x1d, 0x29, 0x9d, 0x7b, 0x34, 0x56, 0x7c, 0xd4, 0x28,
+	0x79, 0xeb, 0xe6, 0x6e, 0x1d, 0xbd, 0x75, 0xa7, 0xf9, 0xda, 0xfb, 0x10, 0xe5, 0x47, 0xdc, 0x91,
+	0x32, 0xb6, 0x26, 0xaa, 0x15, 0x3b, 0xdc, 0xa7, 0x7e, 0x48, 0x4e, 0x24, 0xec, 0x18, 0x16, 0xc2,
+	0x91, 0x3c, 0x51, 0x1a, 0x5b, 0x80, 0x8c, 0x67, 0x9f, 0x11, 0x99, 0xc4, 0x78, 0x43, 0x1a, 0xec,
+	0x87, 0xf9, 0x44, 0x06, 0x1b, 0x81, 0x30, 0xb6, 0x25, 0x27, 0xb5, 0x97, 0xae, 0xa6, 0x3c, 0x7c,
+	0xf1, 0x06, 0xde, 0x83, 0xeb, 0xd1, 0x34, 0x31, 0x91, 0xc9, 0x47, 0x7c, 0x03, 0xc7, 0x65, 0x92,
+	0x89, 0xe4, 0x7e, 0x1c, 0x24, 0x03, 0x25, 0xa1, 0x4c, 0x24, 0x52, 0x87, 0x5a, 0x5c, 0x7e, 0xf9,
+	0x29, 0xf6, 0xab, 0x9f, 0x6e, 0x26, 0x12, 0xe6, 0x06, 0xc2, 0x26, 0x5f, 0xfe, 0x20, 0x47, 0xa4,
+	0xc7, 0xe6, 0x08, 0x11, 0x24, 0x41, 0x16, 0xfb, 0x19, 0x36, 0x9d, 0xd0, 0x11, 0x24, 0xd0, 0x49,
+	0x75, 0xd0, 0x1a, 0xe2, 0xeb, 0x60, 0x0d, 0xb9, 0xb1, 0xd5, 0xb4, 0x3b, 0xd1, 0x62, 0x7c, 0x12,
+	0xe4, 0xce, 0x91, 0xcc, 0x3c, 0x91, 0xe0, 0x4f, 0x61, 0x39, 0x39, 0x29, 0x4f, 0x22, 0xf9, 0x49,
+	0x1d, 0xf2, 0xfe, 0x81, 0x52, 0xf9, 0xed, 0x43, 0x01, 0x72, 0x7b, 0xfb, 0x87, 0x07, 0xeb, 0x1b,
+	0x0d, 0xfe, 0xe3, 0x87, 0x8d, 0x7d, 0x5d, 0x7f, 0x7d, 0xd0, 0xac, 0xa4, 0xd6, 0xfe, 0x2f, 0x0d,
+	0xa9, 0x9d, 0x23, 0xf4, 0xfb, 0x90, 0xe1, 0x2f, 0x81, 0x63, 0x9e, 0x7f, 0x6b, 0xe3, 0x1e, 0x3b,
+	0xf1, 0xad, 0xaf, 0xfe, 0xe3, 0xbf, 0xbf, 0x4d, 0x5d, 0xc7, 0x73, 0xf5, 0xe1, 0xbb, 0x46, 0xb7,
+	0x7f, 0x6a, 0xd4, 0xcf, 0x86, 0x75, 0x56, 0x20, 0x9e, 0x6b, 0x4f, 0xd0, 0x11, 0xa4, 0x0f, 0x06,
+	0x1e, 0x4a, 0x7c, 0x1b, 0xae, 0x25, 0x3f, 0x82, 0xe2, 0x1a, 0x93, 0xbc, 0x80, 0x67, 0x55, 0xc9,
+	0xfd, 0x81, 0x47, 0xe5, 0x0e, 0xa1, 0xa0, 0xbe, 0x63, 0x5e, 0xfa, 0x6a, 0x5c, 0xbb, 0xfc, 0x8d,
+	0x14, 0x63, 0xa6, 0xef, 0x16, 0xbe, 0xa1, 0xea, 0xe3, 0xcf, 0xad, 0xea, 0x7c, 0x9a, 0xe7, 0x16,
+	0x4a, 0x7c, 0x58, 0xae, 0x25, 0xbf, 0x9d, 0xc6, 0xcf, 0xc7, 0x3b, 0xb7, 0xa8, 0x5c, 0x5b, 0xbc,
+	0x9d, 0xb6, 0x3d, 0x74, 0x27, 0xe6, 0xed, 0x4c, 0x7d, 0x25, 0xaa, 0x2d, 0x27, 0x33, 0x08, 0x4d,
+	0x77, 0x99, 0xa6, 0x9b, 0xf8, 0xba, 0xaa, 0xa9, 0xed, 0xf3, 0x3d, 0xd7, 0x9e, 0xac, 0x9d, 0x42,
+	0x86, 0xc1, 0xc4, 0xa8, 0x25, 0x3f, 0x6a, 0x31, 0x00, 0x77, 0xc2, 0x0e, 0x08, 0x01, 0xcc, 0x78,
+	0x91, 0x69, 0x9b, 0xc7, 0x65, 0x5f, 0x1b, 0x43, 0x8a, 0x9f, 0x6b, 0x4f, 0x56, 0xb4, 0x5f, 0x69,
+	0x6b, 0xff, 0x3b, 0x0d, 0x19, 0x06, 0x1a, 0xa1, 0x3e, 0x40, 0x80, 0xa9, 0x46, 0xe7, 0x39, 0x82,
+	0xd2, 0x46, 0xe7, 0x39, 0x0a, 0xc7, 0xe2, 0x3b, 0x4c, 0xf3, 0x22, 0x5e, 0xf0, 0x35, 0x33, 0x40,
+	0xaa, 0xce, 0x30, 0x36, 0xea, 0xd6, 0xb7, 0x02, 0x37, 0xe3, 0xd1, 0x86, 0xe2, 0x24, 0x86, 0xc0,
+	0xd5, 0xe8, 0x36, 0x89, 0x01, 0x56, 0xf1, 0x3d, 0xa6, 0xf4, 0x36, 0xae, 0xaa, 0xce, 0xe5, 0x7a,
+	0x1d, 0xc6, 0x49, 0x15, 0x7f, 0xad, 0x41, 0x39, 0x8c, 0x8f, 0xa2, 0x7b, 0x31, 0xa2, 0xa3, 0x30,
+	0x6b, 0xed, 0xfe, 0x78, 0xa6, 0x44, 0x13, 0xb8, 0xfe, 0x33, 0x42, 0xfa, 0x06, 0xe5, 0x14, 0xbe,
+	0x47, 0x7f, 0xa2, 0xc1, 0x6c, 0x04, 0xf5, 0x44, 0x71, 0x2a, 0x46, 0x30, 0xd5, 0xda, 0x83, 0x4b,
+	0xb8, 0x84, 0x25, 0x8f, 0x98, 0x25, 0x77, 0xf1, 0xad, 0x51, 0x67, 0x78, 0x66, 0x8f, 0x78, 0xb6,
+	0xb0, 0xc6, 0x5f, 0x09, 0x0e, 0x51, 0xc6, 0xae, 0x44, 0x08, 0xf2, 0x8c, 0x5d, 0x89, 0x30, 0xbe,
+	0x39, 0x6e, 0x25, 0x38, 0x30, 0x49, 0x37, 0xfa, 0xff, 0xa7, 0x21, 0xb7, 0xc1, 0x7f, 0x8c, 0x88,
+	0x3c, 0xc8, 0xfb, 0x60, 0x20, 0x5a, 0x8a, 0x03, 0x66, 0x82, 0x8b, 0x43, 0xed, 0x4e, 0x62, 0xbf,
+	0x50, 0xff, 0x90, 0xa9, 0x5f, 0xc6, 0x37, 0x7d, 0xf5, 0xe2, 0x47, 0x8f, 0x75, 0x0e, 0x01, 0xd4,
+	0x8d, 0x4e, 0x87, 0x4e, 0xfd, 0x8f, 0x35, 0x28, 0xaa, 0x98, 0x1d, 0xba, 0x1b, 0x0b, 0x09, 0xa9,
+	0xb0, 0x5f, 0x0d, 0x8f, 0x63, 0x11, 0xfa, 0x1f, 0x33, 0xfd, 0xf7, 0xf0, 0x52, 0x92, 0x7e, 0x87,
+	0xf1, 0x87, 0x4d, 0xe0, 0xa8, 0x5b, 0xbc, 0x09, 0x21, 0x50, 0x2f, 0xde, 0x84, 0x30, 0x68, 0x77,
+	0xb9, 0x09, 0x03, 0xc6, 0x4f, 0x4d, 0x38, 0x07, 0x08, 0x40, 0x36, 0x14, 0xeb, 0x5c, 0xe5, 0x2a,
+	0x15, 0x0d, 0xfe, 0x51, 0x7c, 0x2e, 0x66, 0xeb, 0x45, 0x74, 0x77, 0x4d, 0x97, 0x26, 0x81, 0xb5,
+	0x7f, 0xcc, 0x42, 0xe1, 0x95, 0x61, 0x5a, 0x1e, 0xb1, 0x0c, 0xab, 0x4d, 0xd0, 0x09, 0x64, 0x58,
+	0xad, 0x8c, 0x66, 0x3c, 0x15, 0x7c, 0x8a, 0x66, 0xbc, 0x10, 0x32, 0x83, 0x1f, 0x30, 0xd5, 0x77,
+	0x70, 0xcd, 0x57, 0xdd, 0x0b, 0xe4, 0xd7, 0x19, 0xaa, 0x42, 0xa7, 0x7c, 0x06, 0x59, 0x01, 0xd8,
+	0x47, 0xa4, 0x85, 0xd0, 0x96, 0xda, 0xad, 0xf8, 0xce, 0xc4, 0x5d, 0xa6, 0xea, 0x72, 0x19, 0x33,
+	0x55, 0xf6, 0x07, 0x00, 0x01, 0x66, 0x18, 0xf5, 0xef, 0x08, 0xc4, 0x58, 0x5b, 0x4e, 0x66, 0x10,
+	0x8a, 0x9f, 0x30, 0xc5, 0xf7, 0xf1, 0x9d, 0x58, 0xc5, 0x1d, 0x7f, 0x00, 0x55, 0xde, 0x86, 0xe9,
+	0x2d, 0xc3, 0x3d, 0x45, 0x91, 0xea, 0xa7, 0xfc, 0x90, 0xa0, 0x56, 0x8b, 0xeb, 0x12, 0xaa, 0xee,
+	0x33, 0x55, 0x4b, 0x78, 0x31, 0x56, 0xd5, 0xa9, 0xe1, 0xd2, 0x62, 0x82, 0x4c, 0xc8, 0xf2, 0x1f,
+	0x17, 0x44, 0xdd, 0x19, 0xfa, 0x81, 0x42, 0xd4, 0x9d, 0xe1, 0xdf, 0x23, 0x5c, 0x51, 0xd5, 0x00,
+	0x66, 0xe4, 0x93, 0x3e, 0xba, 0x1d, 0x59, 0x9e, 0xf0, 0xf3, 0x7f, 0x6d, 0x29, 0xa9, 0x5b, 0x28,
+	0x5c, 0x61, 0x0a, 0x31, 0xbe, 0x1d, 0xbf, 0x7e, 0x82, 0xfd, 0xb9, 0xf6, 0xe4, 0x57, 0x1a, 0xad,
+	0x1a, 0x10, 0x60, 0xaf, 0x23, 0x41, 0x12, 0x85, 0x71, 0x47, 0x82, 0x64, 0x04, 0xb6, 0xc5, 0xef,
+	0x32, 0xed, 0xcf, 0xf0, 0x4a, 0xac, 0x76, 0xcf, 0x31, 0x2c, 0xf7, 0x0d, 0x71, 0x9e, 0x71, 0x90,
+	0xcd, 0x3d, 0x35, 0xfb, 0x34, 0x60, 0xfe, 0xac, 0x02, 0xd3, 0xf4, 0x9c, 0x4a, 0x0b, 0x76, 0x70,
+	0xbd, 0x8f, 0x9a, 0x33, 0x02, 0xaa, 0x45, 0xcd, 0x19, 0x45, 0x06, 0x62, 0x0a, 0x36, 0xfb, 0x11,
+	0x3a, 0x61, 0x5c, 0xd4, 0xf1, 0x1e, 0x14, 0x14, 0x10, 0x00, 0xc5, 0x48, 0x0c, 0x43, 0x76, 0xd1,
+	0x32, 0x11, 0x83, 0x20, 0xe0, 0x65, 0xa6, 0xb4, 0x86, 0xaf, 0x85, 0x95, 0x76, 0x38, 0x1b, 0xd5,
+	0xfa, 0x25, 0x14, 0x55, 0xb4, 0x00, 0xc5, 0x08, 0x8d, 0x60, 0x82, 0xd1, 0xec, 0x18, 0x07, 0x36,
+	0xc4, 0xa4, 0x09, 0xff, 0x27, 0xf7, 0x92, 0x97, 0x6a, 0xff, 0x1c, 0x72, 0x02, 0x43, 0x88, 0x9b,
+	0x6f, 0x18, 0x45, 0x8c, 0x9b, 0x6f, 0x04, 0x80, 0x88, 0x39, 0xfd, 0x31, 0xb5, 0xf4, 0xae, 0x24,
+	0x4b, 0x92, 0x50, 0xf9, 0x92, 0x78, 0x49, 0x2a, 0x03, 0x5c, 0x2c, 0x49, 0xa5, 0x72, 0x4f, 0x1d,
+	0xab, 0xf2, 0x84, 0x78, 0x22, 0xa4, 0xe4, 0x25, 0x10, 0x25, 0x48, 0x54, 0xf3, 0x3f, 0x1e, 0xc7,
+	0x92, 0x78, 0x60, 0x0f, 0xb4, 0x8a, 0xe4, 0x8f, 0xfe, 0x10, 0x20, 0x00, 0x3c, 0xa2, 0x67, 0xb0,
+	0x58, 0xd4, 0x34, 0x7a, 0x06, 0x8b, 0xc7, 0x4c, 0x62, 0x12, 0x49, 0xa0, 0x9c, 0x5f, 0x1a, 0xa8,
+	0xfa, 0xbf, 0xd4, 0x00, 0x8d, 0x02, 0x24, 0xe8, 0x69, 0xbc, 0x8a, 0x58, 0x40, 0xb6, 0xf6, 0xce,
+	0xd5, 0x98, 0x13, 0xeb, 0x45, 0x60, 0x57, 0x9b, 0x0d, 0xe9, 0xbf, 0xa5, 0x96, 0x7d, 0xa3, 0x41,
+	0x29, 0x04, 0xb1, 0xa0, 0x87, 0x09, 0xeb, 0x1c, 0x01, 0x75, 0x6b, 0x8f, 0x2e, 0xe5, 0x4b, 0x3c,
+	0x9f, 0x29, 0xbb, 0x42, 0x1e, 0xd1, 0xff, 0x54, 0x83, 0x72, 0x18, 0x97, 0x41, 0x09, 0x0a, 0x46,
+	0x90, 0xe1, 0xda, 0xca, 0xe5, 0x8c, 0x57, 0x58, 0xad, 0xe0, 0xd4, 0xfe, 0x39, 0xe4, 0x04, 0x9c,
+	0x13, 0x17, 0x16, 0x61, 0x60, 0x39, 0x2e, 0x2c, 0x22, 0x58, 0x50, 0x52, 0x58, 0x38, 0x76, 0x97,
+	0x28, 0x91, 0x28, 0x40, 0x9f, 0x24, 0x95, 0xe3, 0x23, 0x31, 0x82, 0x18, 0x8d, 0x55, 0x19, 0x44,
+	0xa2, 0x84, 0x7c, 0x50, 0x82, 0xc4, 0x4b, 0x22, 0x31, 0x8a, 0x18, 0x25, 0x45, 0x22, 0xd3, 0xaa,
+	0x44, 0x62, 0x80, 0xd0, 0xc4, 0x45, 0xe2, 0x08, 0x6c, 0x1e, 0x17, 0x89, 0xa3, 0x20, 0x4f, 0xd2,
+	0xda, 0x32, 0xe5, 0xa1, 0x48, 0x9c, 0x8f, 0x41, 0x74, 0xd0, 0x3b, 0x09, 0x3e, 0x8d, 0x85, 0xe4,
+	0x6b, 0xcf, 0xae, 0xc8, 0x3d, 0x3e, 0x02, 0xf8, 0x6a, 0xc8, 0x08, 0xf8, 0x5b, 0x0d, 0x16, 0xe2,
+	0x20, 0x21, 0x94, 0xa0, 0x2c, 0x01, 0xcf, 0xaf, 0xad, 0x5e, 0x95, 0xfd, 0x0a, 0x7e, 0xf3, 0x63,
+	0xe2, 0x45, 0xe5, 0x5f, 0xbe, 0x5f, 0xd2, 0xfe, 0xfd, 0xfb, 0x25, 0xed, 0x3f, 0xbf, 0x5f, 0xd2,
+	0xfe, 0xea, 0xbf, 0x96, 0xa6, 0x8e, 0xb3, 0xec, 0x7f, 0x82, 0xbd, 0xfb, 0x9b, 0x00, 0x00, 0x00,
+	0xff, 0xff, 0xdd, 0x84, 0xb6, 0xd7, 0x90, 0x36, 0x00, 0x00,
+}
diff --git a/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.proto b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.proto
new file mode 100644
index 000000000..2c18ce101
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/etcdserver/etcdserverpb/rpc.proto
@@ -0,0 +1,1053 @@
+syntax = "proto3";
+package etcdserverpb;
+
+import "gogoproto/gogo.proto";
+import "etcd/mvcc/mvccpb/kv.proto";
+import "etcd/auth/authpb/auth.proto";
+
+// for grpc-gateway
+import "google/api/annotations.proto";
+
+option (gogoproto.marshaler_all) = true;
+option (gogoproto.unmarshaler_all) = true;
+
+service KV {
+  // Range gets the keys in the range from the key-value store.
+  rpc Range(RangeRequest) returns (RangeResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/kv/range"
+        body: "*"
+    };
+  }
+
+  // Put puts the given key into the key-value store.
+  // A put request increments the revision of the key-value store
+  // and generates one event in the event history.
+  rpc Put(PutRequest) returns (PutResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/kv/put"
+        body: "*"
+    };
+  }
+
+  // DeleteRange deletes the given range from the key-value store.
+  // A delete request increments the revision of the key-value store
+  // and generates a delete event in the event history for every deleted key.
+  rpc DeleteRange(DeleteRangeRequest) returns (DeleteRangeResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/kv/deleterange"
+        body: "*"
+    };
+  }
+
+  // Txn processes multiple requests in a single transaction.
+  // A txn request increments the revision of the key-value store
+  // and generates events with the same revision for every completed request.
+  // It is not allowed to modify the same key several times within one txn.
+  rpc Txn(TxnRequest) returns (TxnResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/kv/txn"
+        body: "*"
+    };
+  }
+
+  // Compact compacts the event history in the etcd key-value store. The key-value
+  // store should be periodically compacted or the event history will continue to grow
+  // indefinitely.
+  rpc Compact(CompactionRequest) returns (CompactionResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/kv/compaction"
+        body: "*"
+    };
+  }
+}
+
+service Watch {
+  // Watch watches for events happening or that have happened. Both input and output
+  // are streams; the input stream is for creating and canceling watchers and the output
+  // stream sends events. One watch RPC can watch on multiple key ranges, streaming events
+  // for several watches at once. The entire event history can be watched starting from the
+  // last compaction revision.
+  rpc Watch(stream WatchRequest) returns (stream WatchResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/watch"
+        body: "*"
+    };
+  }
+}
+
+service Lease {
+  // LeaseGrant creates a lease which expires if the server does not receive a keepAlive
+  // within a given time to live period. All keys attached to the lease will be expired and
+  // deleted if the lease expires. Each expired key generates a delete event in the event history.
+  rpc LeaseGrant(LeaseGrantRequest) returns (LeaseGrantResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/lease/grant"
+        body: "*"
+    };
+  }
+
+  // LeaseRevoke revokes a lease. All keys attached to the lease will expire and be deleted.
+  rpc LeaseRevoke(LeaseRevokeRequest) returns (LeaseRevokeResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/kv/lease/revoke"
+        body: "*"
+    };
+  }
+
+  // LeaseKeepAlive keeps the lease alive by streaming keep alive requests from the client
+  // to the server and streaming keep alive responses from the server to the client.
+  rpc LeaseKeepAlive(stream LeaseKeepAliveRequest) returns (stream LeaseKeepAliveResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/lease/keepalive"
+        body: "*"
+    };
+  }
+
+  // LeaseTimeToLive retrieves lease information.
+  rpc LeaseTimeToLive(LeaseTimeToLiveRequest) returns (LeaseTimeToLiveResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/kv/lease/timetolive"
+        body: "*"
+    };
+  }
+
+  // LeaseLeases lists all existing leases.
+  rpc LeaseLeases(LeaseLeasesRequest) returns (LeaseLeasesResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/kv/lease/leases"
+        body: "*"
+    };
+  }
+}
+
+service Cluster {
+  // MemberAdd adds a member into the cluster.
+  rpc MemberAdd(MemberAddRequest) returns (MemberAddResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/cluster/member/add"
+        body: "*"
+    };
+  }
+
+  // MemberRemove removes an existing member from the cluster.
+  rpc MemberRemove(MemberRemoveRequest) returns (MemberRemoveResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/cluster/member/remove"
+        body: "*"
+    };
+  }
+
+  // MemberUpdate updates the member configuration.
+  rpc MemberUpdate(MemberUpdateRequest) returns (MemberUpdateResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/cluster/member/update"
+        body: "*"
+    };
+  }
+
+  // MemberList lists all the members in the cluster.
+  rpc MemberList(MemberListRequest) returns (MemberListResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/cluster/member/list"
+        body: "*"
+    };
+  }
+}
+
+service Maintenance {
+  // Alarm activates, deactivates, and queries alarms regarding cluster health.
+  rpc Alarm(AlarmRequest) returns (AlarmResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/maintenance/alarm"
+        body: "*"
+    };
+  }
+
+  // Status gets the status of the member.
+  rpc Status(StatusRequest) returns (StatusResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/maintenance/status"
+        body: "*"
+    };
+  }
+
+  // Defragment defragments a member's backend database to recover storage space.
+  rpc Defragment(DefragmentRequest) returns (DefragmentResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/maintenance/defragment"
+        body: "*"
+    };
+  }
+
+  // Hash computes the hash of the KV's backend.
+  // This is designed for testing; do not use this in production when there
+  // are ongoing transactions.
+  rpc Hash(HashRequest) returns (HashResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/maintenance/hash"
+        body: "*"
+    };
+  }
+
+  // HashKV computes the hash of all MVCC keys up to a given revision.
+  rpc HashKV(HashKVRequest) returns (HashKVResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/maintenance/hash"
+        body: "*"
+    };
+  }
+
+  // Snapshot sends a snapshot of the entire backend from a member over a stream to a client.
+  rpc Snapshot(SnapshotRequest) returns (stream SnapshotResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/maintenance/snapshot"
+        body: "*"
+    };
+  }
+
+  // MoveLeader requests current leader node to transfer its leadership to transferee.
+  rpc MoveLeader(MoveLeaderRequest) returns (MoveLeaderResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/maintenance/transfer-leadership"
+        body: "*"
+    };
+  }
+}
+
+service Auth {
+  // AuthEnable enables authentication.
+  rpc AuthEnable(AuthEnableRequest) returns (AuthEnableResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/enable"
+        body: "*"
+    };
+  }
+
+  // AuthDisable disables authentication.
+  rpc AuthDisable(AuthDisableRequest) returns (AuthDisableResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/disable"
+        body: "*"
+    };
+  }
+
+  // Authenticate processes an authenticate request.
+  rpc Authenticate(AuthenticateRequest) returns (AuthenticateResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/authenticate"
+        body: "*"
+    };
+  }
+
+  // UserAdd adds a new user.
+  rpc UserAdd(AuthUserAddRequest) returns (AuthUserAddResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/user/add"
+        body: "*"
+    };
+  }
+
+  // UserGet gets detailed user information.
+  rpc UserGet(AuthUserGetRequest) returns (AuthUserGetResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/user/get"
+        body: "*"
+    };
+  }
+
+  // UserList gets a list of all users.
+  rpc UserList(AuthUserListRequest) returns (AuthUserListResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/user/list"
+        body: "*"
+    };
+  }
+
+  // UserDelete deletes a specified user.
+  rpc UserDelete(AuthUserDeleteRequest) returns (AuthUserDeleteResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/user/delete"
+        body: "*"
+    };
+  }
+
+  // UserChangePassword changes the password of a specified user.
+  rpc UserChangePassword(AuthUserChangePasswordRequest) returns (AuthUserChangePasswordResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/user/changepw"
+        body: "*"
+    };
+  }
+
+  // UserGrant grants a role to a specified user.
+  rpc UserGrantRole(AuthUserGrantRoleRequest) returns (AuthUserGrantRoleResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/user/grant"
+        body: "*"
+    };
+  }
+
+  // UserRevokeRole revokes a role of specified user.
+  rpc UserRevokeRole(AuthUserRevokeRoleRequest) returns (AuthUserRevokeRoleResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/user/revoke"
+        body: "*"
+    };
+  }
+
+  // RoleAdd adds a new role.
+  rpc RoleAdd(AuthRoleAddRequest) returns (AuthRoleAddResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/role/add"
+        body: "*"
+    };
+  }
+
+  // RoleGet gets detailed role information.
+  rpc RoleGet(AuthRoleGetRequest) returns (AuthRoleGetResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/role/get"
+        body: "*"
+    };
+  }
+
+  // RoleList gets lists of all roles.
+  rpc RoleList(AuthRoleListRequest) returns (AuthRoleListResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/role/list"
+        body: "*"
+    };
+  }
+
+  // RoleDelete deletes a specified role.
+  rpc RoleDelete(AuthRoleDeleteRequest) returns (AuthRoleDeleteResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/role/delete"
+        body: "*"
+    };
+  }
+
+  // RoleGrantPermission grants a permission of a specified key or range to a specified role.
+  rpc RoleGrantPermission(AuthRoleGrantPermissionRequest) returns (AuthRoleGrantPermissionResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/role/grant"
+        body: "*"
+    };
+  }
+
+  // RoleRevokePermission revokes a key or range permission of a specified role.
+  rpc RoleRevokePermission(AuthRoleRevokePermissionRequest) returns (AuthRoleRevokePermissionResponse) {
+      option (google.api.http) = {
+        post: "/v3alpha/auth/role/revoke"
+        body: "*"
+    };
+  }
+}
+
+message ResponseHeader {
+  // cluster_id is the ID of the cluster which sent the response.
+  uint64 cluster_id = 1;
+  // member_id is the ID of the member which sent the response.
+  uint64 member_id = 2;
+  // revision is the key-value store revision when the request was applied.
+  int64 revision = 3;
+  // raft_term is the raft term when the request was applied.
+  uint64 raft_term = 4;
+}
+
+message RangeRequest {
+  enum SortOrder {
+	NONE = 0; // default, no sorting
+	ASCEND = 1; // lowest target value first
+	DESCEND = 2; // highest target value first
+  }
+  enum SortTarget {
+	KEY = 0;
+	VERSION = 1;
+	CREATE = 2;
+	MOD = 3;
+	VALUE = 4;
+  }
+
+  // key is the first key for the range. If range_end is not given, the request only looks up key.
+  bytes key = 1;
+  // range_end is the upper bound on the requested range [key, range_end).
+  // If range_end is '\0', the range is all keys >= key.
+  // If range_end is key plus one (e.g., "aa"+1 == "ab", "a\xff"+1 == "b"),
+  // then the range request gets all keys prefixed with key.
+  // If both key and range_end are '\0', then the range request returns all keys.
+  bytes range_end = 2;
+  // limit is a limit on the number of keys returned for the request. When limit is set to 0,
+  // it is treated as no limit.
+  int64 limit = 3;
+  // revision is the point-in-time of the key-value store to use for the range.
+  // If revision is less or equal to zero, the range is over the newest key-value store.
+  // If the revision has been compacted, ErrCompacted is returned as a response.
+  int64 revision = 4;
+
+  // sort_order is the order for returned sorted results.
+  SortOrder sort_order = 5;
+
+  // sort_target is the key-value field to use for sorting.
+  SortTarget sort_target = 6;
+
+  // serializable sets the range request to use serializable member-local reads.
+  // Range requests are linearizable by default; linearizable requests have higher
+  // latency and lower throughput than serializable requests but reflect the current
+  // consensus of the cluster. For better performance, in exchange for possible stale reads,
+  // a serializable range request is served locally without needing to reach consensus
+  // with other nodes in the cluster.
+  bool serializable = 7;
+
+  // keys_only when set returns only the keys and not the values.
+  bool keys_only = 8;
+
+  // count_only when set returns only the count of the keys in the range.
+  bool count_only = 9;
+
+  // min_mod_revision is the lower bound for returned key mod revisions; all keys with
+  // lesser mod revisions will be filtered away.
+  int64 min_mod_revision = 10;
+
+  // max_mod_revision is the upper bound for returned key mod revisions; all keys with
+  // greater mod revisions will be filtered away.
+  int64 max_mod_revision = 11;
+
+  // min_create_revision is the lower bound for returned key create revisions; all keys with
+  // lesser create trevisions will be filtered away.
+  int64 min_create_revision = 12;
+
+  // max_create_revision is the upper bound for returned key create revisions; all keys with
+  // greater create revisions will be filtered away.
+  int64 max_create_revision = 13;
+}
+
+message RangeResponse {
+  ResponseHeader header = 1;
+  // kvs is the list of key-value pairs matched by the range request.
+  // kvs is empty when count is requested.
+  repeated mvccpb.KeyValue kvs = 2;
+  // more indicates if there are more keys to return in the requested range.
+  bool more = 3;
+  // count is set to the number of keys within the range when requested.
+  int64 count = 4;
+}
+
+message PutRequest {
+  // key is the key, in bytes, to put into the key-value store.
+  bytes key = 1;
+  // value is the value, in bytes, to associate with the key in the key-value store.
+  bytes value = 2;
+  // lease is the lease ID to associate with the key in the key-value store. A lease
+  // value of 0 indicates no lease.
+  int64 lease = 3;
+
+  // If prev_kv is set, etcd gets the previous key-value pair before changing it.
+  // The previous key-value pair will be returned in the put response.
+  bool prev_kv = 4;
+
+  // If ignore_value is set, etcd updates the key using its current value.
+  // Returns an error if the key does not exist.
+  bool ignore_value = 5;
+
+  // If ignore_lease is set, etcd updates the key using its current lease.
+  // Returns an error if the key does not exist.
+  bool ignore_lease = 6;
+}
+
+message PutResponse {
+  ResponseHeader header = 1;
+  // if prev_kv is set in the request, the previous key-value pair will be returned.
+  mvccpb.KeyValue prev_kv = 2;
+}
+
+message DeleteRangeRequest {
+  // key is the first key to delete in the range.
+  bytes key = 1;
+  // range_end is the key following the last key to delete for the range [key, range_end).
+  // If range_end is not given, the range is defined to contain only the key argument.
+  // If range_end is one bit larger than the given key, then the range is all the keys
+  // with the prefix (the given key).
+  // If range_end is '\0', the range is all keys greater than or equal to the key argument.
+  bytes range_end = 2;
+
+  // If prev_kv is set, etcd gets the previous key-value pairs before deleting it.
+  // The previous key-value pairs will be returned in the delete response.
+  bool prev_kv = 3;
+}
+
+message DeleteRangeResponse {
+  ResponseHeader header = 1;
+  // deleted is the number of keys deleted by the delete range request.
+  int64 deleted = 2;
+  // if prev_kv is set in the request, the previous key-value pairs will be returned.
+  repeated mvccpb.KeyValue prev_kvs = 3;
+}
+
+message RequestOp {
+  // request is a union of request types accepted by a transaction.
+  oneof request {
+    RangeRequest request_range = 1;
+    PutRequest request_put = 2;
+    DeleteRangeRequest request_delete_range = 3;
+    TxnRequest request_txn = 4;
+  }
+}
+
+message ResponseOp {
+  // response is a union of response types returned by a transaction.
+  oneof response {
+    RangeResponse response_range = 1;
+    PutResponse response_put = 2;
+    DeleteRangeResponse response_delete_range = 3;
+    TxnResponse response_txn = 4;
+  }
+}
+
+message Compare {
+  enum CompareResult {
+    EQUAL = 0;
+    GREATER = 1;
+    LESS = 2;
+    NOT_EQUAL = 3;
+  }
+  enum CompareTarget {
+    VERSION = 0;
+    CREATE = 1;
+    MOD = 2;
+    VALUE= 3;
+    LEASE = 4;
+  }
+  // result is logical comparison operation for this comparison.
+  CompareResult result = 1;
+  // target is the key-value field to inspect for the comparison.
+  CompareTarget target = 2;
+  // key is the subject key for the comparison operation.
+  bytes key = 3;
+  oneof target_union {
+    // version is the version of the given key
+    int64 version = 4;
+    // create_revision is the creation revision of the given key
+    int64 create_revision = 5;
+    // mod_revision is the last modified revision of the given key.
+    int64 mod_revision = 6;
+    // value is the value of the given key, in bytes.
+    bytes value = 7;
+    // lease is the lease id of the given key.
+    int64 lease = 8;
+    // leave room for more target_union field tags, jump to 64
+  }
+
+  // range_end compares the given target to all keys in the range [key, range_end).
+  // See RangeRequest for more details on key ranges.
+  bytes range_end = 64;
+  // TODO: fill out with most of the rest of RangeRequest fields when needed.
+}
+
+// From google paxosdb paper:
+// Our implementation hinges around a powerful primitive which we call MultiOp. All other database
+// operations except for iteration are implemented as a single call to MultiOp. A MultiOp is applied atomically
+// and consists of three components:
+// 1. A list of tests called guard. Each test in guard checks a single entry in the database. It may check
+// for the absence or presence of a value, or compare with a given value. Two different tests in the guard
+// may apply to the same or different entries in the database. All tests in the guard are applied and
+// MultiOp returns the results. If all tests are true, MultiOp executes t op (see item 2 below), otherwise
+// it executes f op (see item 3 below).
+// 2. A list of database operations called t op. Each operation in the list is either an insert, delete, or
+// lookup operation, and applies to a single database entry. Two different operations in the list may apply
+// to the same or different entries in the database. These operations are executed
+// if guard evaluates to
+// true.
+// 3. A list of database operations called f op. Like t op, but executed if guard evaluates to false.
+message TxnRequest {
+  // compare is a list of predicates representing a conjunction of terms.
+  // If the comparisons succeed, then the success requests will be processed in order,
+  // and the response will contain their respective responses in order.
+  // If the comparisons fail, then the failure requests will be processed in order,
+  // and the response will contain their respective responses in order.
+  repeated Compare compare = 1;
+  // success is a list of requests which will be applied when compare evaluates to true.
+  repeated RequestOp success = 2;
+  // failure is a list of requests which will be applied when compare evaluates to false.
+  repeated RequestOp failure = 3;
+}
+
+message TxnResponse {
+  ResponseHeader header = 1;
+  // succeeded is set to true if the compare evaluated to true or false otherwise.
+  bool succeeded = 2;
+  // responses is a list of responses corresponding to the results from applying
+  // success if succeeded is true or failure if succeeded is false.
+  repeated ResponseOp responses = 3;
+}
+
+// CompactionRequest compacts the key-value store up to a given revision. All superseded keys
+// with a revision less than the compaction revision will be removed.
+message CompactionRequest {
+  // revision is the key-value store revision for the compaction operation.
+  int64 revision = 1;
+  // physical is set so the RPC will wait until the compaction is physically
+  // applied to the local database such that compacted entries are totally
+  // removed from the backend database.
+  bool physical = 2;
+}
+
+message CompactionResponse {
+  ResponseHeader header = 1;
+}
+
+message HashRequest {
+}
+
+message HashKVRequest {
+  // revision is the key-value store revision for the hash operation.
+  int64 revision = 1;
+}
+
+message HashKVResponse {
+  ResponseHeader header = 1;
+  // hash is the hash value computed from the responding member's MVCC keys up to a given revision.
+  uint32 hash = 2;
+  // compact_revision is the compacted revision of key-value store when hash begins.
+  int64 compact_revision = 3;
+}
+
+message HashResponse {
+  ResponseHeader header = 1;
+  // hash is the hash value computed from the responding member's KV's backend.
+  uint32 hash = 2;
+}
+
+message SnapshotRequest {
+}
+
+message SnapshotResponse {
+  // header has the current key-value store information. The first header in the snapshot
+  // stream indicates the point in time of the snapshot.
+  ResponseHeader header = 1;
+
+  // remaining_bytes is the number of blob bytes to be sent after this message
+  uint64 remaining_bytes = 2;
+
+  // blob contains the next chunk of the snapshot in the snapshot stream.
+  bytes blob = 3;
+}
+
+message WatchRequest {
+  // request_union is a request to either create a new watcher or cancel an existing watcher.
+  oneof request_union {
+    WatchCreateRequest create_request = 1;
+    WatchCancelRequest cancel_request = 2;
+  }
+}
+
+message WatchCreateRequest {
+  // key is the key to register for watching.
+  bytes key = 1;
+  // range_end is the end of the range [key, range_end) to watch. If range_end is not given,
+  // only the key argument is watched. If range_end is equal to '\0', all keys greater than
+  // or equal to the key argument are watched.
+  // If the range_end is one bit larger than the given key,
+  // then all keys with the prefix (the given key) will be watched.
+  bytes range_end = 2;
+  // start_revision is an optional revision to watch from (inclusive). No start_revision is "now".
+  int64 start_revision = 3;
+  // progress_notify is set so that the etcd server will periodically send a WatchResponse with
+  // no events to the new watcher if there are no recent events. It is useful when clients
+  // wish to recover a disconnected watcher starting from a recent known revision.
+  // The etcd server may decide how often it will send notifications based on current load.
+  bool progress_notify = 4;
+
+  enum FilterType {
+  // filter out put event.
+  NOPUT = 0;
+  // filter out delete event.
+  NODELETE = 1;
+  }
+  // filters filter the events at server side before it sends back to the watcher.
+  repeated FilterType filters = 5;
+
+  // If prev_kv is set, created watcher gets the previous KV before the event happens.
+  // If the previous KV is already compacted, nothing will be returned.
+  bool prev_kv = 6;
+}
+
+message WatchCancelRequest {
+  // watch_id is the watcher id to cancel so that no more events are transmitted.
+  int64 watch_id = 1;
+}
+
+message WatchResponse {
+  ResponseHeader header = 1;
+  // watch_id is the ID of the watcher that corresponds to the response.
+  int64 watch_id = 2;
+  // created is set to true if the response is for a create watch request.
+  // The client should record the watch_id and expect to receive events for
+  // the created watcher from the same stream.
+  // All events sent to the created watcher will attach with the same watch_id.
+  bool created = 3;
+  // canceled is set to true if the response is for a cancel watch request.
+  // No further events will be sent to the canceled watcher.
+  bool canceled = 4;
+  // compact_revision is set to the minimum index if a watcher tries to watch
+  // at a compacted index.
+  //
+  // This happens when creating a watcher at a compacted revision or the watcher cannot
+  // catch up with the progress of the key-value store.
+  //
+  // The client should treat the watcher as canceled and should not try to create any
+  // watcher with the same start_revision again.
+  int64 compact_revision  = 5;
+
+  // cancel_reason indicates the reason for canceling the watcher.
+  string cancel_reason = 6;
+
+  repeated mvccpb.Event events = 11;
+}
+
+message LeaseGrantRequest {
+  // TTL is the advisory time-to-live in seconds.
+  int64 TTL = 1;
+  // ID is the requested ID for the lease. If ID is set to 0, the lessor chooses an ID.
+  int64 ID = 2;
+}
+
+message LeaseGrantResponse {
+  ResponseHeader header = 1;
+  // ID is the lease ID for the granted lease.
+  int64 ID = 2;
+  // TTL is the server chosen lease time-to-live in seconds.
+  int64 TTL = 3;
+  string error = 4;
+}
+
+message LeaseRevokeRequest {
+  // ID is the lease ID to revoke. When the ID is revoked, all associated keys will be deleted.
+  int64 ID = 1;
+}
+
+message LeaseRevokeResponse {
+  ResponseHeader header = 1;
+}
+
+message LeaseKeepAliveRequest {
+  // ID is the lease ID for the lease to keep alive.
+  int64 ID = 1;
+}
+
+message LeaseKeepAliveResponse {
+  ResponseHeader header = 1;
+  // ID is the lease ID from the keep alive request.
+  int64 ID = 2;
+  // TTL is the new time-to-live for the lease.
+  int64 TTL = 3;
+}
+
+message LeaseTimeToLiveRequest {
+  // ID is the lease ID for the lease.
+  int64 ID = 1;
+  // keys is true to query all the keys attached to this lease.
+  bool keys = 2;
+}
+
+message LeaseTimeToLiveResponse {
+  ResponseHeader header = 1;
+  // ID is the lease ID from the keep alive request.
+  int64 ID = 2;
+  // TTL is the remaining TTL in seconds for the lease; the lease will expire in under TTL+1 seconds.
+  int64 TTL = 3;
+  // GrantedTTL is the initial granted time in seconds upon lease creation/renewal.
+  int64 grantedTTL = 4;
+  // Keys is the list of keys attached to this lease.
+  repeated bytes keys = 5;
+}
+
+message LeaseLeasesRequest {
+}
+
+message LeaseStatus {
+  int64 ID = 1;
+  // TODO: int64 TTL = 2;
+}
+
+message LeaseLeasesResponse {
+  ResponseHeader header = 1;
+  repeated LeaseStatus leases = 2;
+}
+
+message Member {
+  // ID is the member ID for this member.
+  uint64 ID = 1;
+  // name is the human-readable name of the member. If the member is not started, the name will be an empty string.
+  string name = 2;
+  // peerURLs is the list of URLs the member exposes to the cluster for communication.
+  repeated string peerURLs = 3;
+  // clientURLs is the list of URLs the member exposes to clients for communication. If the member is not started, clientURLs will be empty.
+  repeated string clientURLs = 4;
+}
+
+message MemberAddRequest {
+  // peerURLs is the list of URLs the added member will use to communicate with the cluster.
+  repeated string peerURLs = 1;
+}
+
+message MemberAddResponse {
+  ResponseHeader header = 1;
+  // member is the member information for the added member.
+  Member member = 2;
+  // members is a list of all members after adding the new member.
+  repeated Member members = 3;
+}
+
+message MemberRemoveRequest {
+  // ID is the member ID of the member to remove.
+  uint64 ID = 1;
+}
+
+message MemberRemoveResponse {
+  ResponseHeader header = 1;
+  // members is a list of all members after removing the member.
+  repeated Member members = 2;
+}
+
+message MemberUpdateRequest {
+  // ID is the member ID of the member to update.
+  uint64 ID = 1;
+  // peerURLs is the new list of URLs the member will use to communicate with the cluster.
+  repeated string peerURLs = 2;
+}
+
+message MemberUpdateResponse{
+  ResponseHeader header = 1;
+  // members is a list of all members after updating the member.
+  repeated Member members = 2;
+}
+
+message MemberListRequest {
+}
+
+message MemberListResponse {
+  ResponseHeader header = 1;
+  // members is a list of all members associated with the cluster.
+  repeated Member members = 2;
+}
+
+message DefragmentRequest {
+}
+
+message DefragmentResponse {
+  ResponseHeader header = 1;
+}
+
+message MoveLeaderRequest {
+  // targetID is the node ID for the new leader.
+  uint64 targetID = 1;
+}
+
+message MoveLeaderResponse {
+  ResponseHeader header = 1;
+}
+
+enum AlarmType {
+	NONE = 0; // default, used to query if any alarm is active
+	NOSPACE = 1; // space quota is exhausted
+	CORRUPT = 2; // kv store corruption detected
+}
+
+message AlarmRequest {
+  enum AlarmAction {
+	GET = 0;
+	ACTIVATE = 1;
+	DEACTIVATE = 2;
+  }
+  // action is the kind of alarm request to issue. The action
+  // may GET alarm statuses, ACTIVATE an alarm, or DEACTIVATE a
+  // raised alarm.
+  AlarmAction action = 1;
+  // memberID is the ID of the member associated with the alarm. If memberID is 0, the
+  // alarm request covers all members.
+  uint64 memberID = 2;
+  // alarm is the type of alarm to consider for this request.
+  AlarmType alarm = 3;
+}
+
+message AlarmMember {
+  // memberID is the ID of the member associated with the raised alarm.
+  uint64 memberID = 1;
+  // alarm is the type of alarm which has been raised.
+  AlarmType alarm = 2;
+}
+
+message AlarmResponse {
+  ResponseHeader header = 1;
+  // alarms is a list of alarms associated with the alarm request.
+  repeated AlarmMember alarms = 2;
+}
+
+message StatusRequest {
+}
+
+message StatusResponse {
+  ResponseHeader header = 1;
+  // version is the cluster protocol version used by the responding member.
+  string version = 2;
+  // dbSize is the size of the backend database, in bytes, of the responding member.
+  int64 dbSize = 3;
+  // leader is the member ID which the responding member believes is the current leader.
+  uint64 leader = 4;
+  // raftIndex is the current raft index of the responding member.
+  uint64 raftIndex = 5;
+  // raftTerm is the current raft term of the responding member.
+  uint64 raftTerm = 6;
+}
+
+message AuthEnableRequest {
+}
+
+message AuthDisableRequest {
+}
+
+message AuthenticateRequest {
+  string name = 1;
+  string password = 2;
+}
+
+message AuthUserAddRequest {
+  string name = 1;
+  string password = 2;
+}
+
+message AuthUserGetRequest {
+  string name = 1;
+}
+
+message AuthUserDeleteRequest {
+  // name is the name of the user to delete.
+  string name = 1;
+}
+
+message AuthUserChangePasswordRequest {
+  // name is the name of the user whose password is being changed.
+  string name = 1;
+  // password is the new password for the user.
+  string password = 2;
+}
+
+message AuthUserGrantRoleRequest {
+  // user is the name of the user which should be granted a given role.
+  string user = 1;
+  // role is the name of the role to grant to the user.
+  string role = 2;
+}
+
+message AuthUserRevokeRoleRequest {
+  string name = 1;
+  string role = 2;
+}
+
+message AuthRoleAddRequest {
+  // name is the name of the role to add to the authentication system.
+  string name = 1;
+}
+
+message AuthRoleGetRequest {
+  string role = 1;
+}
+
+message AuthUserListRequest {
+}
+
+message AuthRoleListRequest {
+}
+
+message AuthRoleDeleteRequest {
+  string role = 1;
+}
+
+message AuthRoleGrantPermissionRequest {
+  // name is the name of the role which will be granted the permission.
+  string name = 1;
+  // perm is the permission to grant to the role.
+  authpb.Permission perm = 2;
+}
+
+message AuthRoleRevokePermissionRequest {
+  string role = 1;
+  string key = 2;
+  string range_end = 3;
+}
+
+message AuthEnableResponse {
+  ResponseHeader header = 1;
+}
+
+message AuthDisableResponse {
+  ResponseHeader header = 1;
+}
+
+message AuthenticateResponse {
+  ResponseHeader header = 1;
+  // token is an authorized token that can be used in succeeding RPCs
+  string token = 2;
+}
+
+message AuthUserAddResponse {
+  ResponseHeader header = 1;
+}
+
+message AuthUserGetResponse {
+  ResponseHeader header = 1;
+
+  repeated string roles = 2;
+}
+
+message AuthUserDeleteResponse {
+  ResponseHeader header = 1;
+}
+
+message AuthUserChangePasswordResponse {
+  ResponseHeader header = 1;
+}
+
+message AuthUserGrantRoleResponse {
+  ResponseHeader header = 1;
+}
+
+message AuthUserRevokeRoleResponse {
+  ResponseHeader header = 1;
+}
+
+message AuthRoleAddResponse {
+  ResponseHeader header = 1;
+}
+
+message AuthRoleGetResponse {
+  ResponseHeader header = 1;
+
+  repeated authpb.Permission perm = 2;
+}
+
+message AuthRoleListResponse {
+  ResponseHeader header = 1;
+
+  repeated string roles = 2;
+}
+
+message AuthUserListResponse {
+  ResponseHeader header = 1;
+
+  repeated string users = 2;
+}
+
+message AuthRoleDeleteResponse {
+  ResponseHeader header = 1;
+}
+
+message AuthRoleGrantPermissionResponse {
+  ResponseHeader header = 1;
+}
+
+message AuthRoleRevokePermissionResponse {
+  ResponseHeader header = 1;
+}
diff --git a/vendor/github.com/coreos/etcd/mvcc/mvccpb/kv.pb.go b/vendor/github.com/coreos/etcd/mvcc/mvccpb/kv.pb.go
new file mode 100644
index 000000000..7033f1326
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/mvcc/mvccpb/kv.pb.go
@@ -0,0 +1,735 @@
+// Code generated by protoc-gen-gogo.
+// source: kv.proto
+// DO NOT EDIT!
+
+/*
+	Package mvccpb is a generated protocol buffer package.
+
+	It is generated from these files:
+		kv.proto
+
+	It has these top-level messages:
+		KeyValue
+		Event
+*/
+package mvccpb
+
+import (
+	"fmt"
+
+	proto "github.com/golang/protobuf/proto"
+
+	math "math"
+
+	io "io"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type Event_EventType int32
+
+const (
+	PUT    Event_EventType = 0
+	DELETE Event_EventType = 1
+)
+
+var Event_EventType_name = map[int32]string{
+	0: "PUT",
+	1: "DELETE",
+}
+var Event_EventType_value = map[string]int32{
+	"PUT":    0,
+	"DELETE": 1,
+}
+
+func (x Event_EventType) String() string {
+	return proto.EnumName(Event_EventType_name, int32(x))
+}
+func (Event_EventType) EnumDescriptor() ([]byte, []int) { return fileDescriptorKv, []int{1, 0} }
+
+type KeyValue struct {
+	// key is the key in bytes. An empty key is not allowed.
+	Key []byte `protobuf:"bytes,1,opt,name=key,proto3" json:"key,omitempty"`
+	// create_revision is the revision of last creation on this key.
+	CreateRevision int64 `protobuf:"varint,2,opt,name=create_revision,json=createRevision,proto3" json:"create_revision,omitempty"`
+	// mod_revision is the revision of last modification on this key.
+	ModRevision int64 `protobuf:"varint,3,opt,name=mod_revision,json=modRevision,proto3" json:"mod_revision,omitempty"`
+	// version is the version of the key. A deletion resets
+	// the version to zero and any modification of the key
+	// increases its version.
+	Version int64 `protobuf:"varint,4,opt,name=version,proto3" json:"version,omitempty"`
+	// value is the value held by the key, in bytes.
+	Value []byte `protobuf:"bytes,5,opt,name=value,proto3" json:"value,omitempty"`
+	// lease is the ID of the lease that attached to key.
+	// When the attached lease expires, the key will be deleted.
+	// If lease is 0, then no lease is attached to the key.
+	Lease int64 `protobuf:"varint,6,opt,name=lease,proto3" json:"lease,omitempty"`
+}
+
+func (m *KeyValue) Reset()                    { *m = KeyValue{} }
+func (m *KeyValue) String() string            { return proto.CompactTextString(m) }
+func (*KeyValue) ProtoMessage()               {}
+func (*KeyValue) Descriptor() ([]byte, []int) { return fileDescriptorKv, []int{0} }
+
+type Event struct {
+	// type is the kind of event. If type is a PUT, it indicates
+	// new data has been stored to the key. If type is a DELETE,
+	// it indicates the key was deleted.
+	Type Event_EventType `protobuf:"varint,1,opt,name=type,proto3,enum=mvccpb.Event_EventType" json:"type,omitempty"`
+	// kv holds the KeyValue for the event.
+	// A PUT event contains current kv pair.
+	// A PUT event with kv.Version=1 indicates the creation of a key.
+	// A DELETE/EXPIRE event contains the deleted key with
+	// its modification revision set to the revision of deletion.
+	Kv *KeyValue `protobuf:"bytes,2,opt,name=kv" json:"kv,omitempty"`
+	// prev_kv holds the key-value pair before the event happens.
+	PrevKv *KeyValue `protobuf:"bytes,3,opt,name=prev_kv,json=prevKv" json:"prev_kv,omitempty"`
+}
+
+func (m *Event) Reset()                    { *m = Event{} }
+func (m *Event) String() string            { return proto.CompactTextString(m) }
+func (*Event) ProtoMessage()               {}
+func (*Event) Descriptor() ([]byte, []int) { return fileDescriptorKv, []int{1} }
+
+func init() {
+	proto.RegisterType((*KeyValue)(nil), "mvccpb.KeyValue")
+	proto.RegisterType((*Event)(nil), "mvccpb.Event")
+	proto.RegisterEnum("mvccpb.Event_EventType", Event_EventType_name, Event_EventType_value)
+}
+func (m *KeyValue) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *KeyValue) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if len(m.Key) > 0 {
+		dAtA[i] = 0xa
+		i++
+		i = encodeVarintKv(dAtA, i, uint64(len(m.Key)))
+		i += copy(dAtA[i:], m.Key)
+	}
+	if m.CreateRevision != 0 {
+		dAtA[i] = 0x10
+		i++
+		i = encodeVarintKv(dAtA, i, uint64(m.CreateRevision))
+	}
+	if m.ModRevision != 0 {
+		dAtA[i] = 0x18
+		i++
+		i = encodeVarintKv(dAtA, i, uint64(m.ModRevision))
+	}
+	if m.Version != 0 {
+		dAtA[i] = 0x20
+		i++
+		i = encodeVarintKv(dAtA, i, uint64(m.Version))
+	}
+	if len(m.Value) > 0 {
+		dAtA[i] = 0x2a
+		i++
+		i = encodeVarintKv(dAtA, i, uint64(len(m.Value)))
+		i += copy(dAtA[i:], m.Value)
+	}
+	if m.Lease != 0 {
+		dAtA[i] = 0x30
+		i++
+		i = encodeVarintKv(dAtA, i, uint64(m.Lease))
+	}
+	return i, nil
+}
+
+func (m *Event) Marshal() (dAtA []byte, err error) {
+	size := m.Size()
+	dAtA = make([]byte, size)
+	n, err := m.MarshalTo(dAtA)
+	if err != nil {
+		return nil, err
+	}
+	return dAtA[:n], nil
+}
+
+func (m *Event) MarshalTo(dAtA []byte) (int, error) {
+	var i int
+	_ = i
+	var l int
+	_ = l
+	if m.Type != 0 {
+		dAtA[i] = 0x8
+		i++
+		i = encodeVarintKv(dAtA, i, uint64(m.Type))
+	}
+	if m.Kv != nil {
+		dAtA[i] = 0x12
+		i++
+		i = encodeVarintKv(dAtA, i, uint64(m.Kv.Size()))
+		n1, err := m.Kv.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n1
+	}
+	if m.PrevKv != nil {
+		dAtA[i] = 0x1a
+		i++
+		i = encodeVarintKv(dAtA, i, uint64(m.PrevKv.Size()))
+		n2, err := m.PrevKv.MarshalTo(dAtA[i:])
+		if err != nil {
+			return 0, err
+		}
+		i += n2
+	}
+	return i, nil
+}
+
+func encodeFixed64Kv(dAtA []byte, offset int, v uint64) int {
+	dAtA[offset] = uint8(v)
+	dAtA[offset+1] = uint8(v >> 8)
+	dAtA[offset+2] = uint8(v >> 16)
+	dAtA[offset+3] = uint8(v >> 24)
+	dAtA[offset+4] = uint8(v >> 32)
+	dAtA[offset+5] = uint8(v >> 40)
+	dAtA[offset+6] = uint8(v >> 48)
+	dAtA[offset+7] = uint8(v >> 56)
+	return offset + 8
+}
+func encodeFixed32Kv(dAtA []byte, offset int, v uint32) int {
+	dAtA[offset] = uint8(v)
+	dAtA[offset+1] = uint8(v >> 8)
+	dAtA[offset+2] = uint8(v >> 16)
+	dAtA[offset+3] = uint8(v >> 24)
+	return offset + 4
+}
+func encodeVarintKv(dAtA []byte, offset int, v uint64) int {
+	for v >= 1<<7 {
+		dAtA[offset] = uint8(v&0x7f | 0x80)
+		v >>= 7
+		offset++
+	}
+	dAtA[offset] = uint8(v)
+	return offset + 1
+}
+func (m *KeyValue) Size() (n int) {
+	var l int
+	_ = l
+	l = len(m.Key)
+	if l > 0 {
+		n += 1 + l + sovKv(uint64(l))
+	}
+	if m.CreateRevision != 0 {
+		n += 1 + sovKv(uint64(m.CreateRevision))
+	}
+	if m.ModRevision != 0 {
+		n += 1 + sovKv(uint64(m.ModRevision))
+	}
+	if m.Version != 0 {
+		n += 1 + sovKv(uint64(m.Version))
+	}
+	l = len(m.Value)
+	if l > 0 {
+		n += 1 + l + sovKv(uint64(l))
+	}
+	if m.Lease != 0 {
+		n += 1 + sovKv(uint64(m.Lease))
+	}
+	return n
+}
+
+func (m *Event) Size() (n int) {
+	var l int
+	_ = l
+	if m.Type != 0 {
+		n += 1 + sovKv(uint64(m.Type))
+	}
+	if m.Kv != nil {
+		l = m.Kv.Size()
+		n += 1 + l + sovKv(uint64(l))
+	}
+	if m.PrevKv != nil {
+		l = m.PrevKv.Size()
+		n += 1 + l + sovKv(uint64(l))
+	}
+	return n
+}
+
+func sovKv(x uint64) (n int) {
+	for {
+		n++
+		x >>= 7
+		if x == 0 {
+			break
+		}
+	}
+	return n
+}
+func sozKv(x uint64) (n int) {
+	return sovKv(uint64((x << 1) ^ uint64((int64(x) >> 63))))
+}
+func (m *KeyValue) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowKv
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: KeyValue: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: KeyValue: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Key", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKv
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthKv
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Key = append(m.Key[:0], dAtA[iNdEx:postIndex]...)
+			if m.Key == nil {
+				m.Key = []byte{}
+			}
+			iNdEx = postIndex
+		case 2:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field CreateRevision", wireType)
+			}
+			m.CreateRevision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKv
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.CreateRevision |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 3:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field ModRevision", wireType)
+			}
+			m.ModRevision = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKv
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.ModRevision |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 4:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Version", wireType)
+			}
+			m.Version = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKv
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Version |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 5:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Value", wireType)
+			}
+			var byteLen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKv
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				byteLen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if byteLen < 0 {
+				return ErrInvalidLengthKv
+			}
+			postIndex := iNdEx + byteLen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			m.Value = append(m.Value[:0], dAtA[iNdEx:postIndex]...)
+			if m.Value == nil {
+				m.Value = []byte{}
+			}
+			iNdEx = postIndex
+		case 6:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Lease", wireType)
+			}
+			m.Lease = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKv
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Lease |= (int64(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		default:
+			iNdEx = preIndex
+			skippy, err := skipKv(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthKv
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func (m *Event) Unmarshal(dAtA []byte) error {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		preIndex := iNdEx
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return ErrIntOverflowKv
+			}
+			if iNdEx >= l {
+				return io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		fieldNum := int32(wire >> 3)
+		wireType := int(wire & 0x7)
+		if wireType == 4 {
+			return fmt.Errorf("proto: Event: wiretype end group for non-group")
+		}
+		if fieldNum <= 0 {
+			return fmt.Errorf("proto: Event: illegal tag %d (wire type %d)", fieldNum, wire)
+		}
+		switch fieldNum {
+		case 1:
+			if wireType != 0 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Type", wireType)
+			}
+			m.Type = 0
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKv
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				m.Type |= (Event_EventType(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+		case 2:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field Kv", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKv
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthKv
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.Kv == nil {
+				m.Kv = &KeyValue{}
+			}
+			if err := m.Kv.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		case 3:
+			if wireType != 2 {
+				return fmt.Errorf("proto: wrong wireType = %d for field PrevKv", wireType)
+			}
+			var msglen int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return ErrIntOverflowKv
+				}
+				if iNdEx >= l {
+					return io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				msglen |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			if msglen < 0 {
+				return ErrInvalidLengthKv
+			}
+			postIndex := iNdEx + msglen
+			if postIndex > l {
+				return io.ErrUnexpectedEOF
+			}
+			if m.PrevKv == nil {
+				m.PrevKv = &KeyValue{}
+			}
+			if err := m.PrevKv.Unmarshal(dAtA[iNdEx:postIndex]); err != nil {
+				return err
+			}
+			iNdEx = postIndex
+		default:
+			iNdEx = preIndex
+			skippy, err := skipKv(dAtA[iNdEx:])
+			if err != nil {
+				return err
+			}
+			if skippy < 0 {
+				return ErrInvalidLengthKv
+			}
+			if (iNdEx + skippy) > l {
+				return io.ErrUnexpectedEOF
+			}
+			iNdEx += skippy
+		}
+	}
+
+	if iNdEx > l {
+		return io.ErrUnexpectedEOF
+	}
+	return nil
+}
+func skipKv(dAtA []byte) (n int, err error) {
+	l := len(dAtA)
+	iNdEx := 0
+	for iNdEx < l {
+		var wire uint64
+		for shift := uint(0); ; shift += 7 {
+			if shift >= 64 {
+				return 0, ErrIntOverflowKv
+			}
+			if iNdEx >= l {
+				return 0, io.ErrUnexpectedEOF
+			}
+			b := dAtA[iNdEx]
+			iNdEx++
+			wire |= (uint64(b) & 0x7F) << shift
+			if b < 0x80 {
+				break
+			}
+		}
+		wireType := int(wire & 0x7)
+		switch wireType {
+		case 0:
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowKv
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				iNdEx++
+				if dAtA[iNdEx-1] < 0x80 {
+					break
+				}
+			}
+			return iNdEx, nil
+		case 1:
+			iNdEx += 8
+			return iNdEx, nil
+		case 2:
+			var length int
+			for shift := uint(0); ; shift += 7 {
+				if shift >= 64 {
+					return 0, ErrIntOverflowKv
+				}
+				if iNdEx >= l {
+					return 0, io.ErrUnexpectedEOF
+				}
+				b := dAtA[iNdEx]
+				iNdEx++
+				length |= (int(b) & 0x7F) << shift
+				if b < 0x80 {
+					break
+				}
+			}
+			iNdEx += length
+			if length < 0 {
+				return 0, ErrInvalidLengthKv
+			}
+			return iNdEx, nil
+		case 3:
+			for {
+				var innerWire uint64
+				var start int = iNdEx
+				for shift := uint(0); ; shift += 7 {
+					if shift >= 64 {
+						return 0, ErrIntOverflowKv
+					}
+					if iNdEx >= l {
+						return 0, io.ErrUnexpectedEOF
+					}
+					b := dAtA[iNdEx]
+					iNdEx++
+					innerWire |= (uint64(b) & 0x7F) << shift
+					if b < 0x80 {
+						break
+					}
+				}
+				innerWireType := int(innerWire & 0x7)
+				if innerWireType == 4 {
+					break
+				}
+				next, err := skipKv(dAtA[start:])
+				if err != nil {
+					return 0, err
+				}
+				iNdEx = start + next
+			}
+			return iNdEx, nil
+		case 4:
+			return iNdEx, nil
+		case 5:
+			iNdEx += 4
+			return iNdEx, nil
+		default:
+			return 0, fmt.Errorf("proto: illegal wireType %d", wireType)
+		}
+	}
+	panic("unreachable")
+}
+
+var (
+	ErrInvalidLengthKv = fmt.Errorf("proto: negative length found during unmarshaling")
+	ErrIntOverflowKv   = fmt.Errorf("proto: integer overflow")
+)
+
+func init() { proto.RegisterFile("kv.proto", fileDescriptorKv) }
+
+var fileDescriptorKv = []byte{
+	// 303 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0x6c, 0x90, 0x41, 0x4e, 0xc2, 0x40,
+	0x14, 0x86, 0x3b, 0x14, 0x0a, 0x3e, 0x08, 0x36, 0x13, 0x12, 0x27, 0x2e, 0x26, 0x95, 0x8d, 0x18,
+	0x13, 0x4c, 0xf0, 0x06, 0xc6, 0xae, 0x70, 0x61, 0x1a, 0x74, 0x4b, 0x4a, 0x79, 0x21, 0xa4, 0x94,
+	0x69, 0x4a, 0x9d, 0xa4, 0x37, 0x71, 0xef, 0xde, 0x73, 0xb0, 0xe4, 0x08, 0x52, 0x2f, 0x62, 0xfa,
+	0xc6, 0xe2, 0xc6, 0xcd, 0xe4, 0xfd, 0xff, 0xff, 0x65, 0xe6, 0x7f, 0x03, 0x9d, 0x58, 0x8f, 0xd3,
+	0x4c, 0xe5, 0x8a, 0x3b, 0x89, 0x8e, 0xa2, 0x74, 0x71, 0x39, 0x58, 0xa9, 0x95, 0x22, 0xeb, 0xae,
+	0x9a, 0x4c, 0x3a, 0xfc, 0x64, 0xd0, 0x99, 0x62, 0xf1, 0x1a, 0x6e, 0xde, 0x90, 0xbb, 0x60, 0xc7,
+	0x58, 0x08, 0xe6, 0xb1, 0x51, 0x2f, 0xa8, 0x46, 0x7e, 0x0d, 0xe7, 0x51, 0x86, 0x61, 0x8e, 0xf3,
+	0x0c, 0xf5, 0x7a, 0xb7, 0x56, 0x5b, 0xd1, 0xf0, 0xd8, 0xc8, 0x0e, 0xfa, 0xc6, 0x0e, 0x7e, 0x5d,
+	0x7e, 0x05, 0xbd, 0x44, 0x2d, 0xff, 0x28, 0x9b, 0xa8, 0x6e, 0xa2, 0x96, 0x27, 0x44, 0x40, 0x5b,
+	0x63, 0x46, 0x69, 0x93, 0xd2, 0x5a, 0xf2, 0x01, 0xb4, 0x74, 0x55, 0x40, 0xb4, 0xe8, 0x65, 0x23,
+	0x2a, 0x77, 0x83, 0xe1, 0x0e, 0x85, 0x43, 0xb4, 0x11, 0xc3, 0x0f, 0x06, 0x2d, 0x5f, 0xe3, 0x36,
+	0xe7, 0xb7, 0xd0, 0xcc, 0x8b, 0x14, 0xa9, 0x6e, 0x7f, 0x72, 0x31, 0x36, 0x7b, 0x8e, 0x29, 0x34,
+	0xe7, 0xac, 0x48, 0x31, 0x20, 0x88, 0x7b, 0xd0, 0x88, 0x35, 0x75, 0xef, 0x4e, 0xdc, 0x1a, 0xad,
+	0x17, 0x0f, 0x1a, 0xb1, 0xe6, 0x37, 0xd0, 0x4e, 0x33, 0xd4, 0xf3, 0x58, 0x53, 0xf9, 0xff, 0x30,
+	0xa7, 0x02, 0xa6, 0x7a, 0xe8, 0xc1, 0xd9, 0xe9, 0x7e, 0xde, 0x06, 0xfb, 0xf9, 0x65, 0xe6, 0x5a,
+	0x1c, 0xc0, 0x79, 0xf4, 0x9f, 0xfc, 0x99, 0xef, 0xb2, 0x07, 0xb1, 0x3f, 0x4a, 0xeb, 0x70, 0x94,
+	0xd6, 0xbe, 0x94, 0xec, 0x50, 0x4a, 0xf6, 0x55, 0x4a, 0xf6, 0xfe, 0x2d, 0xad, 0x85, 0x43, 0xff,
+	0x7e, 0xff, 0x13, 0x00, 0x00, 0xff, 0xff, 0xb5, 0x45, 0x92, 0x5d, 0xa1, 0x01, 0x00, 0x00,
+}
diff --git a/vendor/github.com/coreos/etcd/mvcc/mvccpb/kv.proto b/vendor/github.com/coreos/etcd/mvcc/mvccpb/kv.proto
new file mode 100644
index 000000000..23c911b7d
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/mvcc/mvccpb/kv.proto
@@ -0,0 +1,49 @@
+syntax = "proto3";
+package mvccpb;
+
+import "gogoproto/gogo.proto";
+
+option (gogoproto.marshaler_all) = true;
+option (gogoproto.sizer_all) = true;
+option (gogoproto.unmarshaler_all) = true;
+option (gogoproto.goproto_getters_all) = false;
+option (gogoproto.goproto_enum_prefix_all) = false;
+
+message KeyValue {
+  // key is the key in bytes. An empty key is not allowed.
+  bytes key = 1;
+  // create_revision is the revision of last creation on this key.
+  int64 create_revision = 2;
+  // mod_revision is the revision of last modification on this key.
+  int64 mod_revision = 3;
+  // version is the version of the key. A deletion resets
+  // the version to zero and any modification of the key
+  // increases its version.
+  int64 version = 4;
+  // value is the value held by the key, in bytes.
+  bytes value = 5;
+  // lease is the ID of the lease that attached to key.
+  // When the attached lease expires, the key will be deleted.
+  // If lease is 0, then no lease is attached to the key.
+  int64 lease = 6;
+}
+
+message Event {
+  enum EventType {
+    PUT = 0;
+    DELETE = 1;
+  }
+  // type is the kind of event. If type is a PUT, it indicates
+  // new data has been stored to the key. If type is a DELETE,
+  // it indicates the key was deleted.
+  EventType type = 1;
+  // kv holds the KeyValue for the event.
+  // A PUT event contains current kv pair.
+  // A PUT event with kv.Version=1 indicates the creation of a key.
+  // A DELETE/EXPIRE event contains the deleted key with
+  // its modification revision set to the revision of deletion.
+  KeyValue kv = 2;
+
+  // prev_kv holds the key-value pair before the event happens.
+  KeyValue prev_kv = 3;
+}
diff --git a/vendor/github.com/coreos/etcd/pkg/tlsutil/doc.go b/vendor/github.com/coreos/etcd/pkg/tlsutil/doc.go
new file mode 100644
index 000000000..3b6aa670b
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/pkg/tlsutil/doc.go
@@ -0,0 +1,16 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package tlsutil provides utility functions for handling TLS.
+package tlsutil
diff --git a/vendor/github.com/coreos/etcd/pkg/tlsutil/tlsutil.go b/vendor/github.com/coreos/etcd/pkg/tlsutil/tlsutil.go
new file mode 100644
index 000000000..79b1f632e
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/pkg/tlsutil/tlsutil.go
@@ -0,0 +1,72 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package tlsutil
+
+import (
+	"crypto/tls"
+	"crypto/x509"
+	"encoding/pem"
+	"io/ioutil"
+)
+
+// NewCertPool creates x509 certPool with provided CA files.
+func NewCertPool(CAFiles []string) (*x509.CertPool, error) {
+	certPool := x509.NewCertPool()
+
+	for _, CAFile := range CAFiles {
+		pemByte, err := ioutil.ReadFile(CAFile)
+		if err != nil {
+			return nil, err
+		}
+
+		for {
+			var block *pem.Block
+			block, pemByte = pem.Decode(pemByte)
+			if block == nil {
+				break
+			}
+			cert, err := x509.ParseCertificate(block.Bytes)
+			if err != nil {
+				return nil, err
+			}
+			certPool.AddCert(cert)
+		}
+	}
+
+	return certPool, nil
+}
+
+// NewCert generates TLS cert by using the given cert,key and parse function.
+func NewCert(certfile, keyfile string, parseFunc func([]byte, []byte) (tls.Certificate, error)) (*tls.Certificate, error) {
+	cert, err := ioutil.ReadFile(certfile)
+	if err != nil {
+		return nil, err
+	}
+
+	key, err := ioutil.ReadFile(keyfile)
+	if err != nil {
+		return nil, err
+	}
+
+	if parseFunc == nil {
+		parseFunc = tls.X509KeyPair
+	}
+
+	tlsCert, err := parseFunc(cert, key)
+	if err != nil {
+		return nil, err
+	}
+	return &tlsCert, nil
+}
diff --git a/vendor/github.com/coreos/etcd/pkg/transport/doc.go b/vendor/github.com/coreos/etcd/pkg/transport/doc.go
new file mode 100644
index 000000000..37658ce59
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/pkg/transport/doc.go
@@ -0,0 +1,17 @@
+// Copyright 2015 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package transport implements various HTTP transport utilities based on Go
+// net package.
+package transport
diff --git a/vendor/github.com/coreos/etcd/pkg/transport/keepalive_listener.go b/vendor/github.com/coreos/etcd/pkg/transport/keepalive_listener.go
new file mode 100644
index 000000000..6ccae4ee4
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/pkg/transport/keepalive_listener.go
@@ -0,0 +1,94 @@
+// Copyright 2015 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transport
+
+import (
+	"crypto/tls"
+	"fmt"
+	"net"
+	"time"
+)
+
+type keepAliveConn interface {
+	SetKeepAlive(bool) error
+	SetKeepAlivePeriod(d time.Duration) error
+}
+
+// NewKeepAliveListener returns a listener that listens on the given address.
+// Be careful when wrap around KeepAliveListener with another Listener if TLSInfo is not nil.
+// Some pkgs (like go/http) might expect Listener to return TLSConn type to start TLS handshake.
+// http://tldp.org/HOWTO/TCP-Keepalive-HOWTO/overview.html
+func NewKeepAliveListener(l net.Listener, scheme string, tlscfg *tls.Config) (net.Listener, error) {
+	if scheme == "https" {
+		if tlscfg == nil {
+			return nil, fmt.Errorf("cannot listen on TLS for given listener: KeyFile and CertFile are not presented")
+		}
+		return newTLSKeepaliveListener(l, tlscfg), nil
+	}
+
+	return &keepaliveListener{
+		Listener: l,
+	}, nil
+}
+
+type keepaliveListener struct{ net.Listener }
+
+func (kln *keepaliveListener) Accept() (net.Conn, error) {
+	c, err := kln.Listener.Accept()
+	if err != nil {
+		return nil, err
+	}
+	kac := c.(keepAliveConn)
+	// detection time: tcp_keepalive_time + tcp_keepalive_probes + tcp_keepalive_intvl
+	// default on linux:  30 + 8 * 30
+	// default on osx:    30 + 8 * 75
+	kac.SetKeepAlive(true)
+	kac.SetKeepAlivePeriod(30 * time.Second)
+	return c, nil
+}
+
+// A tlsKeepaliveListener implements a network listener (net.Listener) for TLS connections.
+type tlsKeepaliveListener struct {
+	net.Listener
+	config *tls.Config
+}
+
+// Accept waits for and returns the next incoming TLS connection.
+// The returned connection c is a *tls.Conn.
+func (l *tlsKeepaliveListener) Accept() (c net.Conn, err error) {
+	c, err = l.Listener.Accept()
+	if err != nil {
+		return
+	}
+	kac := c.(keepAliveConn)
+	// detection time: tcp_keepalive_time + tcp_keepalive_probes + tcp_keepalive_intvl
+	// default on linux:  30 + 8 * 30
+	// default on osx:    30 + 8 * 75
+	kac.SetKeepAlive(true)
+	kac.SetKeepAlivePeriod(30 * time.Second)
+	c = tls.Server(c, l.config)
+	return
+}
+
+// NewListener creates a Listener which accepts connections from an inner
+// Listener and wraps each connection with Server.
+// The configuration config must be non-nil and must have
+// at least one certificate.
+func newTLSKeepaliveListener(inner net.Listener, config *tls.Config) net.Listener {
+	l := &tlsKeepaliveListener{}
+	l.Listener = inner
+	l.config = config
+	return l
+}
diff --git a/vendor/github.com/coreos/etcd/pkg/transport/limit_listen.go b/vendor/github.com/coreos/etcd/pkg/transport/limit_listen.go
new file mode 100644
index 000000000..930c54206
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/pkg/transport/limit_listen.go
@@ -0,0 +1,80 @@
+// Copyright 2013 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+// Package transport provides network utility functions, complementing the more
+// common ones in the net package.
+package transport
+
+import (
+	"errors"
+	"net"
+	"sync"
+	"time"
+)
+
+var (
+	ErrNotTCP = errors.New("only tcp connections have keepalive")
+)
+
+// LimitListener returns a Listener that accepts at most n simultaneous
+// connections from the provided Listener.
+func LimitListener(l net.Listener, n int) net.Listener {
+	return &limitListener{l, make(chan struct{}, n)}
+}
+
+type limitListener struct {
+	net.Listener
+	sem chan struct{}
+}
+
+func (l *limitListener) acquire() { l.sem <- struct{}{} }
+func (l *limitListener) release() { <-l.sem }
+
+func (l *limitListener) Accept() (net.Conn, error) {
+	l.acquire()
+	c, err := l.Listener.Accept()
+	if err != nil {
+		l.release()
+		return nil, err
+	}
+	return &limitListenerConn{Conn: c, release: l.release}, nil
+}
+
+type limitListenerConn struct {
+	net.Conn
+	releaseOnce sync.Once
+	release     func()
+}
+
+func (l *limitListenerConn) Close() error {
+	err := l.Conn.Close()
+	l.releaseOnce.Do(l.release)
+	return err
+}
+
+func (l *limitListenerConn) SetKeepAlive(doKeepAlive bool) error {
+	tcpc, ok := l.Conn.(*net.TCPConn)
+	if !ok {
+		return ErrNotTCP
+	}
+	return tcpc.SetKeepAlive(doKeepAlive)
+}
+
+func (l *limitListenerConn) SetKeepAlivePeriod(d time.Duration) error {
+	tcpc, ok := l.Conn.(*net.TCPConn)
+	if !ok {
+		return ErrNotTCP
+	}
+	return tcpc.SetKeepAlivePeriod(d)
+}
diff --git a/vendor/github.com/coreos/etcd/pkg/transport/listener.go b/vendor/github.com/coreos/etcd/pkg/transport/listener.go
new file mode 100644
index 000000000..555618e6f
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/pkg/transport/listener.go
@@ -0,0 +1,281 @@
+// Copyright 2015 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transport
+
+import (
+	"crypto/ecdsa"
+	"crypto/elliptic"
+	"crypto/rand"
+	"crypto/tls"
+	"crypto/x509"
+	"crypto/x509/pkix"
+	"encoding/pem"
+	"errors"
+	"fmt"
+	"math/big"
+	"net"
+	"os"
+	"path/filepath"
+	"strings"
+	"time"
+
+	"github.com/coreos/etcd/pkg/tlsutil"
+)
+
+func NewListener(addr, scheme string, tlsinfo *TLSInfo) (l net.Listener, err error) {
+	if l, err = newListener(addr, scheme); err != nil {
+		return nil, err
+	}
+	return wrapTLS(addr, scheme, tlsinfo, l)
+}
+
+func newListener(addr string, scheme string) (net.Listener, error) {
+	if scheme == "unix" || scheme == "unixs" {
+		// unix sockets via unix://laddr
+		return NewUnixListener(addr)
+	}
+	return net.Listen("tcp", addr)
+}
+
+func wrapTLS(addr, scheme string, tlsinfo *TLSInfo, l net.Listener) (net.Listener, error) {
+	if scheme != "https" && scheme != "unixs" {
+		return l, nil
+	}
+	return newTLSListener(l, tlsinfo, checkSAN)
+}
+
+type TLSInfo struct {
+	CertFile           string
+	KeyFile            string
+	CAFile             string // TODO: deprecate this in v4
+	TrustedCAFile      string
+	ClientCertAuth     bool
+	CRLFile            string
+	InsecureSkipVerify bool
+
+	// ServerName ensures the cert matches the given host in case of discovery / virtual hosting
+	ServerName string
+
+	// HandshakeFailure is optionally called when a connection fails to handshake. The
+	// connection will be closed immediately afterwards.
+	HandshakeFailure func(*tls.Conn, error)
+
+	selfCert bool
+
+	// parseFunc exists to simplify testing. Typically, parseFunc
+	// should be left nil. In that case, tls.X509KeyPair will be used.
+	parseFunc func([]byte, []byte) (tls.Certificate, error)
+
+	// AllowedCN is a CN which must be provided by a client.
+	AllowedCN string
+}
+
+func (info TLSInfo) String() string {
+	return fmt.Sprintf("cert = %s, key = %s, ca = %s, trusted-ca = %s, client-cert-auth = %v, crl-file = %s", info.CertFile, info.KeyFile, info.CAFile, info.TrustedCAFile, info.ClientCertAuth, info.CRLFile)
+}
+
+func (info TLSInfo) Empty() bool {
+	return info.CertFile == "" && info.KeyFile == ""
+}
+
+func SelfCert(dirpath string, hosts []string) (info TLSInfo, err error) {
+	if err = os.MkdirAll(dirpath, 0700); err != nil {
+		return
+	}
+
+	certPath := filepath.Join(dirpath, "cert.pem")
+	keyPath := filepath.Join(dirpath, "key.pem")
+	_, errcert := os.Stat(certPath)
+	_, errkey := os.Stat(keyPath)
+	if errcert == nil && errkey == nil {
+		info.CertFile = certPath
+		info.KeyFile = keyPath
+		info.selfCert = true
+		return
+	}
+
+	serialNumberLimit := new(big.Int).Lsh(big.NewInt(1), 128)
+	serialNumber, err := rand.Int(rand.Reader, serialNumberLimit)
+	if err != nil {
+		return
+	}
+
+	tmpl := x509.Certificate{
+		SerialNumber: serialNumber,
+		Subject:      pkix.Name{Organization: []string{"etcd"}},
+		NotBefore:    time.Now(),
+		NotAfter:     time.Now().Add(365 * (24 * time.Hour)),
+
+		KeyUsage:              x509.KeyUsageKeyEncipherment | x509.KeyUsageDigitalSignature,
+		ExtKeyUsage:           []x509.ExtKeyUsage{x509.ExtKeyUsageServerAuth},
+		BasicConstraintsValid: true,
+	}
+
+	for _, host := range hosts {
+		h, _, _ := net.SplitHostPort(host)
+		if ip := net.ParseIP(h); ip != nil {
+			tmpl.IPAddresses = append(tmpl.IPAddresses, ip)
+		} else {
+			tmpl.DNSNames = append(tmpl.DNSNames, h)
+		}
+	}
+
+	priv, err := ecdsa.GenerateKey(elliptic.P521(), rand.Reader)
+	if err != nil {
+		return
+	}
+
+	derBytes, err := x509.CreateCertificate(rand.Reader, &tmpl, &tmpl, &priv.PublicKey, priv)
+	if err != nil {
+		return
+	}
+
+	certOut, err := os.Create(certPath)
+	if err != nil {
+		return
+	}
+	pem.Encode(certOut, &pem.Block{Type: "CERTIFICATE", Bytes: derBytes})
+	certOut.Close()
+
+	b, err := x509.MarshalECPrivateKey(priv)
+	if err != nil {
+		return
+	}
+	keyOut, err := os.OpenFile(keyPath, os.O_WRONLY|os.O_CREATE|os.O_TRUNC, 0600)
+	if err != nil {
+		return
+	}
+	pem.Encode(keyOut, &pem.Block{Type: "EC PRIVATE KEY", Bytes: b})
+	keyOut.Close()
+
+	return SelfCert(dirpath, hosts)
+}
+
+func (info TLSInfo) baseConfig() (*tls.Config, error) {
+	if info.KeyFile == "" || info.CertFile == "" {
+		return nil, fmt.Errorf("KeyFile and CertFile must both be present[key: %v, cert: %v]", info.KeyFile, info.CertFile)
+	}
+
+	tlsCert, err := tlsutil.NewCert(info.CertFile, info.KeyFile, info.parseFunc)
+	if err != nil {
+		return nil, err
+	}
+
+	cfg := &tls.Config{
+		Certificates: []tls.Certificate{*tlsCert},
+		MinVersion:   tls.VersionTLS12,
+		ServerName:   info.ServerName,
+	}
+
+	if info.AllowedCN != "" {
+		cfg.VerifyPeerCertificate = func(rawCerts [][]byte, verifiedChains [][]*x509.Certificate) error {
+			for _, chains := range verifiedChains {
+				if len(chains) != 0 {
+					if info.AllowedCN == chains[0].Subject.CommonName {
+						return nil
+					}
+				}
+			}
+			return errors.New("CommonName authentication failed")
+		}
+	}
+
+	// this only reloads certs when there's a client request
+	// TODO: support server-side refresh (e.g. inotify, SIGHUP), caching
+	cfg.GetCertificate = func(clientHello *tls.ClientHelloInfo) (*tls.Certificate, error) {
+		return tlsutil.NewCert(info.CertFile, info.KeyFile, info.parseFunc)
+	}
+	cfg.GetClientCertificate = func(unused *tls.CertificateRequestInfo) (*tls.Certificate, error) {
+		return tlsutil.NewCert(info.CertFile, info.KeyFile, info.parseFunc)
+	}
+	return cfg, nil
+}
+
+// cafiles returns a list of CA file paths.
+func (info TLSInfo) cafiles() []string {
+	cs := make([]string, 0)
+	if info.CAFile != "" {
+		cs = append(cs, info.CAFile)
+	}
+	if info.TrustedCAFile != "" {
+		cs = append(cs, info.TrustedCAFile)
+	}
+	return cs
+}
+
+// ServerConfig generates a tls.Config object for use by an HTTP server.
+func (info TLSInfo) ServerConfig() (*tls.Config, error) {
+	cfg, err := info.baseConfig()
+	if err != nil {
+		return nil, err
+	}
+
+	cfg.ClientAuth = tls.NoClientCert
+	if info.CAFile != "" || info.ClientCertAuth {
+		cfg.ClientAuth = tls.RequireAndVerifyClientCert
+	}
+
+	CAFiles := info.cafiles()
+	if len(CAFiles) > 0 {
+		cp, err := tlsutil.NewCertPool(CAFiles)
+		if err != nil {
+			return nil, err
+		}
+		cfg.ClientCAs = cp
+	}
+
+	// "h2" NextProtos is necessary for enabling HTTP2 for go's HTTP server
+	cfg.NextProtos = []string{"h2"}
+
+	return cfg, nil
+}
+
+// ClientConfig generates a tls.Config object for use by an HTTP client.
+func (info TLSInfo) ClientConfig() (*tls.Config, error) {
+	var cfg *tls.Config
+	var err error
+
+	if !info.Empty() {
+		cfg, err = info.baseConfig()
+		if err != nil {
+			return nil, err
+		}
+	} else {
+		cfg = &tls.Config{ServerName: info.ServerName}
+	}
+	cfg.InsecureSkipVerify = info.InsecureSkipVerify
+
+	CAFiles := info.cafiles()
+	if len(CAFiles) > 0 {
+		cfg.RootCAs, err = tlsutil.NewCertPool(CAFiles)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	if info.selfCert {
+		cfg.InsecureSkipVerify = true
+	}
+	return cfg, nil
+}
+
+// IsClosedConnError returns true if the error is from closing listener, cmux.
+// copied from golang.org/x/net/http2/http2.go
+func IsClosedConnError(err error) bool {
+	// 'use of closed network connection' (Go <=1.8)
+	// 'use of closed file or network connection' (Go >1.8, internal/poll.ErrClosing)
+	// 'mux: listener closed' (cmux.ErrListenerClosed)
+	return err != nil && strings.Contains(err.Error(), "closed")
+}
diff --git a/vendor/github.com/coreos/etcd/pkg/transport/listener_tls.go b/vendor/github.com/coreos/etcd/pkg/transport/listener_tls.go
new file mode 100644
index 000000000..6f1600945
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/pkg/transport/listener_tls.go
@@ -0,0 +1,272 @@
+// Copyright 2017 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transport
+
+import (
+	"context"
+	"crypto/tls"
+	"crypto/x509"
+	"fmt"
+	"io/ioutil"
+	"net"
+	"strings"
+	"sync"
+)
+
+// tlsListener overrides a TLS listener so it will reject client
+// certificates with insufficient SAN credentials or CRL revoked
+// certificates.
+type tlsListener struct {
+	net.Listener
+	connc            chan net.Conn
+	donec            chan struct{}
+	err              error
+	handshakeFailure func(*tls.Conn, error)
+	check            tlsCheckFunc
+}
+
+type tlsCheckFunc func(context.Context, *tls.Conn) error
+
+// NewTLSListener handshakes TLS connections and performs optional CRL checking.
+func NewTLSListener(l net.Listener, tlsinfo *TLSInfo) (net.Listener, error) {
+	check := func(context.Context, *tls.Conn) error { return nil }
+	return newTLSListener(l, tlsinfo, check)
+}
+
+func newTLSListener(l net.Listener, tlsinfo *TLSInfo, check tlsCheckFunc) (net.Listener, error) {
+	if tlsinfo == nil || tlsinfo.Empty() {
+		l.Close()
+		return nil, fmt.Errorf("cannot listen on TLS for %s: KeyFile and CertFile are not presented", l.Addr().String())
+	}
+	tlscfg, err := tlsinfo.ServerConfig()
+	if err != nil {
+		return nil, err
+	}
+
+	hf := tlsinfo.HandshakeFailure
+	if hf == nil {
+		hf = func(*tls.Conn, error) {}
+	}
+
+	if len(tlsinfo.CRLFile) > 0 {
+		prevCheck := check
+		check = func(ctx context.Context, tlsConn *tls.Conn) error {
+			if err := prevCheck(ctx, tlsConn); err != nil {
+				return err
+			}
+			st := tlsConn.ConnectionState()
+			if certs := st.PeerCertificates; len(certs) > 0 {
+				return checkCRL(tlsinfo.CRLFile, certs)
+			}
+			return nil
+		}
+	}
+
+	tlsl := &tlsListener{
+		Listener:         tls.NewListener(l, tlscfg),
+		connc:            make(chan net.Conn),
+		donec:            make(chan struct{}),
+		handshakeFailure: hf,
+		check:            check,
+	}
+	go tlsl.acceptLoop()
+	return tlsl, nil
+}
+
+func (l *tlsListener) Accept() (net.Conn, error) {
+	select {
+	case conn := <-l.connc:
+		return conn, nil
+	case <-l.donec:
+		return nil, l.err
+	}
+}
+
+func checkSAN(ctx context.Context, tlsConn *tls.Conn) error {
+	st := tlsConn.ConnectionState()
+	if certs := st.PeerCertificates; len(certs) > 0 {
+		addr := tlsConn.RemoteAddr().String()
+		return checkCertSAN(ctx, certs[0], addr)
+	}
+	return nil
+}
+
+// acceptLoop launches each TLS handshake in a separate goroutine
+// to prevent a hanging TLS connection from blocking other connections.
+func (l *tlsListener) acceptLoop() {
+	var wg sync.WaitGroup
+	var pendingMu sync.Mutex
+
+	pending := make(map[net.Conn]struct{})
+	ctx, cancel := context.WithCancel(context.Background())
+	defer func() {
+		cancel()
+		pendingMu.Lock()
+		for c := range pending {
+			c.Close()
+		}
+		pendingMu.Unlock()
+		wg.Wait()
+		close(l.donec)
+	}()
+
+	for {
+		conn, err := l.Listener.Accept()
+		if err != nil {
+			l.err = err
+			return
+		}
+
+		pendingMu.Lock()
+		pending[conn] = struct{}{}
+		pendingMu.Unlock()
+
+		wg.Add(1)
+		go func() {
+			defer func() {
+				if conn != nil {
+					conn.Close()
+				}
+				wg.Done()
+			}()
+
+			tlsConn := conn.(*tls.Conn)
+			herr := tlsConn.Handshake()
+			pendingMu.Lock()
+			delete(pending, conn)
+			pendingMu.Unlock()
+
+			if herr != nil {
+				l.handshakeFailure(tlsConn, herr)
+				return
+			}
+			if err := l.check(ctx, tlsConn); err != nil {
+				l.handshakeFailure(tlsConn, err)
+				return
+			}
+
+			select {
+			case l.connc <- tlsConn:
+				conn = nil
+			case <-ctx.Done():
+			}
+		}()
+	}
+}
+
+func checkCRL(crlPath string, cert []*x509.Certificate) error {
+	// TODO: cache
+	crlBytes, err := ioutil.ReadFile(crlPath)
+	if err != nil {
+		return err
+	}
+	certList, err := x509.ParseCRL(crlBytes)
+	if err != nil {
+		return err
+	}
+	revokedSerials := make(map[string]struct{})
+	for _, rc := range certList.TBSCertList.RevokedCertificates {
+		revokedSerials[string(rc.SerialNumber.Bytes())] = struct{}{}
+	}
+	for _, c := range cert {
+		serial := string(c.SerialNumber.Bytes())
+		if _, ok := revokedSerials[serial]; ok {
+			return fmt.Errorf("transport: certificate serial %x revoked", serial)
+		}
+	}
+	return nil
+}
+
+func checkCertSAN(ctx context.Context, cert *x509.Certificate, remoteAddr string) error {
+	if len(cert.IPAddresses) == 0 && len(cert.DNSNames) == 0 {
+		return nil
+	}
+	h, _, herr := net.SplitHostPort(remoteAddr)
+	if herr != nil {
+		return herr
+	}
+	if len(cert.IPAddresses) > 0 {
+		cerr := cert.VerifyHostname(h)
+		if cerr == nil {
+			return nil
+		}
+		if len(cert.DNSNames) == 0 {
+			return cerr
+		}
+	}
+	if len(cert.DNSNames) > 0 {
+		ok, err := isHostInDNS(ctx, h, cert.DNSNames)
+		if ok {
+			return nil
+		}
+		errStr := ""
+		if err != nil {
+			errStr = " (" + err.Error() + ")"
+		}
+		return fmt.Errorf("tls: %q does not match any of DNSNames %q"+errStr, h, cert.DNSNames)
+	}
+	return nil
+}
+
+func isHostInDNS(ctx context.Context, host string, dnsNames []string) (ok bool, err error) {
+	// reverse lookup
+	wildcards, names := []string{}, []string{}
+	for _, dns := range dnsNames {
+		if strings.HasPrefix(dns, "*.") {
+			wildcards = append(wildcards, dns[1:])
+		} else {
+			names = append(names, dns)
+		}
+	}
+	lnames, lerr := net.DefaultResolver.LookupAddr(ctx, host)
+	for _, name := range lnames {
+		// strip trailing '.' from PTR record
+		if name[len(name)-1] == '.' {
+			name = name[:len(name)-1]
+		}
+		for _, wc := range wildcards {
+			if strings.HasSuffix(name, wc) {
+				return true, nil
+			}
+		}
+		for _, n := range names {
+			if n == name {
+				return true, nil
+			}
+		}
+	}
+	err = lerr
+
+	// forward lookup
+	for _, dns := range names {
+		addrs, lerr := net.DefaultResolver.LookupHost(ctx, dns)
+		if lerr != nil {
+			err = lerr
+			continue
+		}
+		for _, addr := range addrs {
+			if addr == host {
+				return true, nil
+			}
+		}
+	}
+	return false, err
+}
+
+func (l *tlsListener) Close() error {
+	err := l.Listener.Close()
+	<-l.donec
+	return err
+}
diff --git a/vendor/github.com/coreos/etcd/pkg/transport/timeout_conn.go b/vendor/github.com/coreos/etcd/pkg/transport/timeout_conn.go
new file mode 100644
index 000000000..7e8c02030
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/pkg/transport/timeout_conn.go
@@ -0,0 +1,44 @@
+// Copyright 2015 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transport
+
+import (
+	"net"
+	"time"
+)
+
+type timeoutConn struct {
+	net.Conn
+	wtimeoutd  time.Duration
+	rdtimeoutd time.Duration
+}
+
+func (c timeoutConn) Write(b []byte) (n int, err error) {
+	if c.wtimeoutd > 0 {
+		if err := c.SetWriteDeadline(time.Now().Add(c.wtimeoutd)); err != nil {
+			return 0, err
+		}
+	}
+	return c.Conn.Write(b)
+}
+
+func (c timeoutConn) Read(b []byte) (n int, err error) {
+	if c.rdtimeoutd > 0 {
+		if err := c.SetReadDeadline(time.Now().Add(c.rdtimeoutd)); err != nil {
+			return 0, err
+		}
+	}
+	return c.Conn.Read(b)
+}
diff --git a/vendor/github.com/coreos/etcd/pkg/transport/timeout_dialer.go b/vendor/github.com/coreos/etcd/pkg/transport/timeout_dialer.go
new file mode 100644
index 000000000..6ae39ecfc
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/pkg/transport/timeout_dialer.go
@@ -0,0 +1,36 @@
+// Copyright 2015 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transport
+
+import (
+	"net"
+	"time"
+)
+
+type rwTimeoutDialer struct {
+	wtimeoutd  time.Duration
+	rdtimeoutd time.Duration
+	net.Dialer
+}
+
+func (d *rwTimeoutDialer) Dial(network, address string) (net.Conn, error) {
+	conn, err := d.Dialer.Dial(network, address)
+	tconn := &timeoutConn{
+		rdtimeoutd: d.rdtimeoutd,
+		wtimeoutd:  d.wtimeoutd,
+		Conn:       conn,
+	}
+	return tconn, err
+}
diff --git a/vendor/github.com/coreos/etcd/pkg/transport/timeout_listener.go b/vendor/github.com/coreos/etcd/pkg/transport/timeout_listener.go
new file mode 100644
index 000000000..b35e04955
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/pkg/transport/timeout_listener.go
@@ -0,0 +1,57 @@
+// Copyright 2015 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transport
+
+import (
+	"net"
+	"time"
+)
+
+// NewTimeoutListener returns a listener that listens on the given address.
+// If read/write on the accepted connection blocks longer than its time limit,
+// it will return timeout error.
+func NewTimeoutListener(addr string, scheme string, tlsinfo *TLSInfo, rdtimeoutd, wtimeoutd time.Duration) (net.Listener, error) {
+	ln, err := newListener(addr, scheme)
+	if err != nil {
+		return nil, err
+	}
+	ln = &rwTimeoutListener{
+		Listener:   ln,
+		rdtimeoutd: rdtimeoutd,
+		wtimeoutd:  wtimeoutd,
+	}
+	if ln, err = wrapTLS(addr, scheme, tlsinfo, ln); err != nil {
+		return nil, err
+	}
+	return ln, nil
+}
+
+type rwTimeoutListener struct {
+	net.Listener
+	wtimeoutd  time.Duration
+	rdtimeoutd time.Duration
+}
+
+func (rwln *rwTimeoutListener) Accept() (net.Conn, error) {
+	c, err := rwln.Listener.Accept()
+	if err != nil {
+		return nil, err
+	}
+	return timeoutConn{
+		Conn:       c,
+		wtimeoutd:  rwln.wtimeoutd,
+		rdtimeoutd: rwln.rdtimeoutd,
+	}, nil
+}
diff --git a/vendor/github.com/coreos/etcd/pkg/transport/timeout_transport.go b/vendor/github.com/coreos/etcd/pkg/transport/timeout_transport.go
new file mode 100644
index 000000000..ea16b4c0f
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/pkg/transport/timeout_transport.go
@@ -0,0 +1,51 @@
+// Copyright 2015 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transport
+
+import (
+	"net"
+	"net/http"
+	"time"
+)
+
+// NewTimeoutTransport returns a transport created using the given TLS info.
+// If read/write on the created connection blocks longer than its time limit,
+// it will return timeout error.
+// If read/write timeout is set, transport will not be able to reuse connection.
+func NewTimeoutTransport(info TLSInfo, dialtimeoutd, rdtimeoutd, wtimeoutd time.Duration) (*http.Transport, error) {
+	tr, err := NewTransport(info, dialtimeoutd)
+	if err != nil {
+		return nil, err
+	}
+
+	if rdtimeoutd != 0 || wtimeoutd != 0 {
+		// the timed out connection will timeout soon after it is idle.
+		// it should not be put back to http transport as an idle connection for future usage.
+		tr.MaxIdleConnsPerHost = -1
+	} else {
+		// allow more idle connections between peers to avoid unnecessary port allocation.
+		tr.MaxIdleConnsPerHost = 1024
+	}
+
+	tr.Dial = (&rwTimeoutDialer{
+		Dialer: net.Dialer{
+			Timeout:   dialtimeoutd,
+			KeepAlive: 30 * time.Second,
+		},
+		rdtimeoutd: rdtimeoutd,
+		wtimeoutd:  wtimeoutd,
+	}).Dial
+	return tr, nil
+}
diff --git a/vendor/github.com/coreos/etcd/pkg/transport/tls.go b/vendor/github.com/coreos/etcd/pkg/transport/tls.go
new file mode 100644
index 000000000..62fe0d385
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/pkg/transport/tls.go
@@ -0,0 +1,49 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transport
+
+import (
+	"fmt"
+	"strings"
+	"time"
+)
+
+// ValidateSecureEndpoints scans the given endpoints against tls info, returning only those
+// endpoints that could be validated as secure.
+func ValidateSecureEndpoints(tlsInfo TLSInfo, eps []string) ([]string, error) {
+	t, err := NewTransport(tlsInfo, 5*time.Second)
+	if err != nil {
+		return nil, err
+	}
+	var errs []string
+	var endpoints []string
+	for _, ep := range eps {
+		if !strings.HasPrefix(ep, "https://") {
+			errs = append(errs, fmt.Sprintf("%q is insecure", ep))
+			continue
+		}
+		conn, cerr := t.Dial("tcp", ep[len("https://"):])
+		if cerr != nil {
+			errs = append(errs, fmt.Sprintf("%q failed to dial (%v)", ep, cerr))
+			continue
+		}
+		conn.Close()
+		endpoints = append(endpoints, ep)
+	}
+	if len(errs) != 0 {
+		err = fmt.Errorf("%s", strings.Join(errs, ","))
+	}
+	return endpoints, err
+}
diff --git a/vendor/github.com/coreos/etcd/pkg/transport/transport.go b/vendor/github.com/coreos/etcd/pkg/transport/transport.go
new file mode 100644
index 000000000..4a7fe69d2
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/pkg/transport/transport.go
@@ -0,0 +1,71 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transport
+
+import (
+	"net"
+	"net/http"
+	"strings"
+	"time"
+)
+
+type unixTransport struct{ *http.Transport }
+
+func NewTransport(info TLSInfo, dialtimeoutd time.Duration) (*http.Transport, error) {
+	cfg, err := info.ClientConfig()
+	if err != nil {
+		return nil, err
+	}
+
+	t := &http.Transport{
+		Proxy: http.ProxyFromEnvironment,
+		Dial: (&net.Dialer{
+			Timeout: dialtimeoutd,
+			// value taken from http.DefaultTransport
+			KeepAlive: 30 * time.Second,
+		}).Dial,
+		// value taken from http.DefaultTransport
+		TLSHandshakeTimeout: 10 * time.Second,
+		TLSClientConfig:     cfg,
+	}
+
+	dialer := (&net.Dialer{
+		Timeout:   dialtimeoutd,
+		KeepAlive: 30 * time.Second,
+	})
+	dial := func(net, addr string) (net.Conn, error) {
+		return dialer.Dial("unix", addr)
+	}
+
+	tu := &http.Transport{
+		Proxy:               http.ProxyFromEnvironment,
+		Dial:                dial,
+		TLSHandshakeTimeout: 10 * time.Second,
+		TLSClientConfig:     cfg,
+	}
+	ut := &unixTransport{tu}
+
+	t.RegisterProtocol("unix", ut)
+	t.RegisterProtocol("unixs", ut)
+
+	return t, nil
+}
+
+func (urt *unixTransport) RoundTrip(req *http.Request) (*http.Response, error) {
+	url := *req.URL
+	req.URL = &url
+	req.URL.Scheme = strings.Replace(req.URL.Scheme, "unix", "http", 1)
+	return urt.Transport.RoundTrip(req)
+}
diff --git a/vendor/github.com/coreos/etcd/pkg/transport/unix_listener.go b/vendor/github.com/coreos/etcd/pkg/transport/unix_listener.go
new file mode 100644
index 000000000..123e2036f
--- /dev/null
+++ b/vendor/github.com/coreos/etcd/pkg/transport/unix_listener.go
@@ -0,0 +1,40 @@
+// Copyright 2016 The etcd Authors
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package transport
+
+import (
+	"net"
+	"os"
+)
+
+type unixListener struct{ net.Listener }
+
+func NewUnixListener(addr string) (net.Listener, error) {
+	if err := os.Remove(addr); err != nil && !os.IsNotExist(err) {
+		return nil, err
+	}
+	l, err := net.Listen("unix", addr)
+	if err != nil {
+		return nil, err
+	}
+	return &unixListener{l}, nil
+}
+
+func (ul *unixListener) Close() error {
+	if err := os.Remove(ul.Addr().String()); err != nil && !os.IsNotExist(err) {
+		return err
+	}
+	return ul.Listener.Close()
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/any.go b/vendor/github.com/golang/protobuf/ptypes/any.go
new file mode 100644
index 000000000..b2af97f4a
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/any.go
@@ -0,0 +1,139 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package ptypes
+
+// This file implements functions to marshal proto.Message to/from
+// google.protobuf.Any message.
+
+import (
+	"fmt"
+	"reflect"
+	"strings"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/golang/protobuf/ptypes/any"
+)
+
+const googleApis = "type.googleapis.com/"
+
+// AnyMessageName returns the name of the message contained in a google.protobuf.Any message.
+//
+// Note that regular type assertions should be done using the Is
+// function. AnyMessageName is provided for less common use cases like filtering a
+// sequence of Any messages based on a set of allowed message type names.
+func AnyMessageName(any *any.Any) (string, error) {
+	if any == nil {
+		return "", fmt.Errorf("message is nil")
+	}
+	slash := strings.LastIndex(any.TypeUrl, "/")
+	if slash < 0 {
+		return "", fmt.Errorf("message type url %q is invalid", any.TypeUrl)
+	}
+	return any.TypeUrl[slash+1:], nil
+}
+
+// MarshalAny takes the protocol buffer and encodes it into google.protobuf.Any.
+func MarshalAny(pb proto.Message) (*any.Any, error) {
+	value, err := proto.Marshal(pb)
+	if err != nil {
+		return nil, err
+	}
+	return &any.Any{TypeUrl: googleApis + proto.MessageName(pb), Value: value}, nil
+}
+
+// DynamicAny is a value that can be passed to UnmarshalAny to automatically
+// allocate a proto.Message for the type specified in a google.protobuf.Any
+// message. The allocated message is stored in the embedded proto.Message.
+//
+// Example:
+//
+//   var x ptypes.DynamicAny
+//   if err := ptypes.UnmarshalAny(a, &x); err != nil { ... }
+//   fmt.Printf("unmarshaled message: %v", x.Message)
+type DynamicAny struct {
+	proto.Message
+}
+
+// Empty returns a new proto.Message of the type specified in a
+// google.protobuf.Any message. It returns an error if corresponding message
+// type isn't linked in.
+func Empty(any *any.Any) (proto.Message, error) {
+	aname, err := AnyMessageName(any)
+	if err != nil {
+		return nil, err
+	}
+
+	t := proto.MessageType(aname)
+	if t == nil {
+		return nil, fmt.Errorf("any: message type %q isn't linked in", aname)
+	}
+	return reflect.New(t.Elem()).Interface().(proto.Message), nil
+}
+
+// UnmarshalAny parses the protocol buffer representation in a google.protobuf.Any
+// message and places the decoded result in pb. It returns an error if type of
+// contents of Any message does not match type of pb message.
+//
+// pb can be a proto.Message, or a *DynamicAny.
+func UnmarshalAny(any *any.Any, pb proto.Message) error {
+	if d, ok := pb.(*DynamicAny); ok {
+		if d.Message == nil {
+			var err error
+			d.Message, err = Empty(any)
+			if err != nil {
+				return err
+			}
+		}
+		return UnmarshalAny(any, d.Message)
+	}
+
+	aname, err := AnyMessageName(any)
+	if err != nil {
+		return err
+	}
+
+	mname := proto.MessageName(pb)
+	if aname != mname {
+		return fmt.Errorf("mismatched message type: got %q want %q", aname, mname)
+	}
+	return proto.Unmarshal(any.Value, pb)
+}
+
+// Is returns true if any value contains a given message type.
+func Is(any *any.Any, pb proto.Message) bool {
+	aname, err := AnyMessageName(any)
+	if err != nil {
+		return false
+	}
+
+	return aname == proto.MessageName(pb)
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
new file mode 100644
index 000000000..f34601723
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/any/any.pb.go
@@ -0,0 +1,178 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/any.proto
+
+/*
+Package any is a generated protocol buffer package.
+
+It is generated from these files:
+	google/protobuf/any.proto
+
+It has these top-level messages:
+	Any
+*/
+package any
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// `Any` contains an arbitrary serialized protocol buffer message along with a
+// URL that describes the type of the serialized message.
+//
+// Protobuf library provides support to pack/unpack Any values in the form
+// of utility functions or additional generated methods of the Any type.
+//
+// Example 1: Pack and unpack a message in C++.
+//
+//     Foo foo = ...;
+//     Any any;
+//     any.PackFrom(foo);
+//     ...
+//     if (any.UnpackTo(&foo)) {
+//       ...
+//     }
+//
+// Example 2: Pack and unpack a message in Java.
+//
+//     Foo foo = ...;
+//     Any any = Any.pack(foo);
+//     ...
+//     if (any.is(Foo.class)) {
+//       foo = any.unpack(Foo.class);
+//     }
+//
+//  Example 3: Pack and unpack a message in Python.
+//
+//     foo = Foo(...)
+//     any = Any()
+//     any.Pack(foo)
+//     ...
+//     if any.Is(Foo.DESCRIPTOR):
+//       any.Unpack(foo)
+//       ...
+//
+//  Example 4: Pack and unpack a message in Go
+//
+//      foo := &pb.Foo{...}
+//      any, err := ptypes.MarshalAny(foo)
+//      ...
+//      foo := &pb.Foo{}
+//      if err := ptypes.UnmarshalAny(any, foo); err != nil {
+//        ...
+//      }
+//
+// The pack methods provided by protobuf library will by default use
+// 'type.googleapis.com/full.type.name' as the type URL and the unpack
+// methods only use the fully qualified type name after the last '/'
+// in the type URL, for example "foo.bar.com/x/y.z" will yield type
+// name "y.z".
+//
+//
+// JSON
+// ====
+// The JSON representation of an `Any` value uses the regular
+// representation of the deserialized, embedded message, with an
+// additional field `@type` which contains the type URL. Example:
+//
+//     package google.profile;
+//     message Person {
+//       string first_name = 1;
+//       string last_name = 2;
+//     }
+//
+//     {
+//       "@type": "type.googleapis.com/google.profile.Person",
+//       "firstName": <string>,
+//       "lastName": <string>
+//     }
+//
+// If the embedded message type is well-known and has a custom JSON
+// representation, that representation will be embedded adding a field
+// `value` which holds the custom JSON in addition to the `@type`
+// field. Example (for message [google.protobuf.Duration][]):
+//
+//     {
+//       "@type": "type.googleapis.com/google.protobuf.Duration",
+//       "value": "1.212s"
+//     }
+//
+type Any struct {
+	// A URL/resource name whose content describes the type of the
+	// serialized protocol buffer message.
+	//
+	// For URLs which use the scheme `http`, `https`, or no scheme, the
+	// following restrictions and interpretations apply:
+	//
+	// * If no scheme is provided, `https` is assumed.
+	// * The last segment of the URL's path must represent the fully
+	//   qualified name of the type (as in `path/google.protobuf.Duration`).
+	//   The name should be in a canonical form (e.g., leading "." is
+	//   not accepted).
+	// * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+	//   value in binary format, or produce an error.
+	// * Applications are allowed to cache lookup results based on the
+	//   URL, or have them precompiled into a binary to avoid any
+	//   lookup. Therefore, binary compatibility needs to be preserved
+	//   on changes to types. (Use versioned type names to manage
+	//   breaking changes.)
+	//
+	// Schemes other than `http`, `https` (or the empty scheme) might be
+	// used with implementation specific semantics.
+	//
+	TypeUrl string `protobuf:"bytes,1,opt,name=type_url,json=typeUrl" json:"type_url,omitempty"`
+	// Must be a valid serialized protocol buffer of the above specified type.
+	Value []byte `protobuf:"bytes,2,opt,name=value,proto3" json:"value,omitempty"`
+}
+
+func (m *Any) Reset()                    { *m = Any{} }
+func (m *Any) String() string            { return proto.CompactTextString(m) }
+func (*Any) ProtoMessage()               {}
+func (*Any) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+func (*Any) XXX_WellKnownType() string   { return "Any" }
+
+func (m *Any) GetTypeUrl() string {
+	if m != nil {
+		return m.TypeUrl
+	}
+	return ""
+}
+
+func (m *Any) GetValue() []byte {
+	if m != nil {
+		return m.Value
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*Any)(nil), "google.protobuf.Any")
+}
+
+func init() { proto.RegisterFile("google/protobuf/any.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 185 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4c, 0xcf, 0xcf, 0x4f,
+	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0xcc, 0xab, 0xd4,
+	0x03, 0x73, 0x84, 0xf8, 0x21, 0x52, 0x7a, 0x30, 0x29, 0x25, 0x33, 0x2e, 0x66, 0xc7, 0xbc, 0x4a,
+	0x21, 0x49, 0x2e, 0x8e, 0x92, 0xca, 0x82, 0xd4, 0xf8, 0xd2, 0xa2, 0x1c, 0x09, 0x46, 0x05, 0x46,
+	0x0d, 0xce, 0x20, 0x76, 0x10, 0x3f, 0xb4, 0x28, 0x47, 0x48, 0x84, 0x8b, 0xb5, 0x2c, 0x31, 0xa7,
+	0x34, 0x55, 0x82, 0x49, 0x81, 0x51, 0x83, 0x27, 0x08, 0xc2, 0x71, 0xca, 0xe7, 0x12, 0x4e, 0xce,
+	0xcf, 0xd5, 0x43, 0x33, 0xce, 0x89, 0xc3, 0x31, 0xaf, 0x32, 0x00, 0xc4, 0x09, 0x60, 0x8c, 0x52,
+	0x4d, 0xcf, 0x2c, 0xc9, 0x28, 0x4d, 0xd2, 0x4b, 0xce, 0xcf, 0xd5, 0x4f, 0xcf, 0xcf, 0x49, 0xcc,
+	0x4b, 0x47, 0xb8, 0xa8, 0x00, 0x64, 0x7a, 0x31, 0xc8, 0x61, 0x8b, 0x98, 0x98, 0xdd, 0x03, 0x9c,
+	0x56, 0x31, 0xc9, 0xb9, 0x43, 0x8c, 0x0a, 0x80, 0x2a, 0xd1, 0x0b, 0x4f, 0xcd, 0xc9, 0xf1, 0xce,
+	0xcb, 0x2f, 0xcf, 0x0b, 0x01, 0x29, 0x4d, 0x62, 0x03, 0xeb, 0x35, 0x06, 0x04, 0x00, 0x00, 0xff,
+	0xff, 0x13, 0xf8, 0xe8, 0x42, 0xdd, 0x00, 0x00, 0x00,
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/any/any.proto b/vendor/github.com/golang/protobuf/ptypes/any/any.proto
new file mode 100644
index 000000000..c74866762
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/any/any.proto
@@ -0,0 +1,149 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option go_package = "github.com/golang/protobuf/ptypes/any";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "AnyProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// `Any` contains an arbitrary serialized protocol buffer message along with a
+// URL that describes the type of the serialized message.
+//
+// Protobuf library provides support to pack/unpack Any values in the form
+// of utility functions or additional generated methods of the Any type.
+//
+// Example 1: Pack and unpack a message in C++.
+//
+//     Foo foo = ...;
+//     Any any;
+//     any.PackFrom(foo);
+//     ...
+//     if (any.UnpackTo(&foo)) {
+//       ...
+//     }
+//
+// Example 2: Pack and unpack a message in Java.
+//
+//     Foo foo = ...;
+//     Any any = Any.pack(foo);
+//     ...
+//     if (any.is(Foo.class)) {
+//       foo = any.unpack(Foo.class);
+//     }
+//
+//  Example 3: Pack and unpack a message in Python.
+//
+//     foo = Foo(...)
+//     any = Any()
+//     any.Pack(foo)
+//     ...
+//     if any.Is(Foo.DESCRIPTOR):
+//       any.Unpack(foo)
+//       ...
+//
+//  Example 4: Pack and unpack a message in Go
+//
+//      foo := &pb.Foo{...}
+//      any, err := ptypes.MarshalAny(foo)
+//      ...
+//      foo := &pb.Foo{}
+//      if err := ptypes.UnmarshalAny(any, foo); err != nil {
+//        ...
+//      }
+//
+// The pack methods provided by protobuf library will by default use
+// 'type.googleapis.com/full.type.name' as the type URL and the unpack
+// methods only use the fully qualified type name after the last '/'
+// in the type URL, for example "foo.bar.com/x/y.z" will yield type
+// name "y.z".
+//
+//
+// JSON
+// ====
+// The JSON representation of an `Any` value uses the regular
+// representation of the deserialized, embedded message, with an
+// additional field `@type` which contains the type URL. Example:
+//
+//     package google.profile;
+//     message Person {
+//       string first_name = 1;
+//       string last_name = 2;
+//     }
+//
+//     {
+//       "@type": "type.googleapis.com/google.profile.Person",
+//       "firstName": <string>,
+//       "lastName": <string>
+//     }
+//
+// If the embedded message type is well-known and has a custom JSON
+// representation, that representation will be embedded adding a field
+// `value` which holds the custom JSON in addition to the `@type`
+// field. Example (for message [google.protobuf.Duration][]):
+//
+//     {
+//       "@type": "type.googleapis.com/google.protobuf.Duration",
+//       "value": "1.212s"
+//     }
+//
+message Any {
+  // A URL/resource name whose content describes the type of the
+  // serialized protocol buffer message.
+  //
+  // For URLs which use the scheme `http`, `https`, or no scheme, the
+  // following restrictions and interpretations apply:
+  //
+  // * If no scheme is provided, `https` is assumed.
+  // * The last segment of the URL's path must represent the fully
+  //   qualified name of the type (as in `path/google.protobuf.Duration`).
+  //   The name should be in a canonical form (e.g., leading "." is
+  //   not accepted).
+  // * An HTTP GET on the URL must yield a [google.protobuf.Type][]
+  //   value in binary format, or produce an error.
+  // * Applications are allowed to cache lookup results based on the
+  //   URL, or have them precompiled into a binary to avoid any
+  //   lookup. Therefore, binary compatibility needs to be preserved
+  //   on changes to types. (Use versioned type names to manage
+  //   breaking changes.)
+  //
+  // Schemes other than `http`, `https` (or the empty scheme) might be
+  // used with implementation specific semantics.
+  //
+  string type_url = 1;
+
+  // Must be a valid serialized protocol buffer of the above specified type.
+  bytes value = 2;
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/doc.go b/vendor/github.com/golang/protobuf/ptypes/doc.go
new file mode 100644
index 000000000..c0d595da7
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/doc.go
@@ -0,0 +1,35 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+/*
+Package ptypes contains code for interacting with well-known types.
+*/
+package ptypes
diff --git a/vendor/github.com/golang/protobuf/ptypes/duration.go b/vendor/github.com/golang/protobuf/ptypes/duration.go
new file mode 100644
index 000000000..65cb0f8eb
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/duration.go
@@ -0,0 +1,102 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package ptypes
+
+// This file implements conversions between google.protobuf.Duration
+// and time.Duration.
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	durpb "github.com/golang/protobuf/ptypes/duration"
+)
+
+const (
+	// Range of a durpb.Duration in seconds, as specified in
+	// google/protobuf/duration.proto. This is about 10,000 years in seconds.
+	maxSeconds = int64(10000 * 365.25 * 24 * 60 * 60)
+	minSeconds = -maxSeconds
+)
+
+// validateDuration determines whether the durpb.Duration is valid according to the
+// definition in google/protobuf/duration.proto. A valid durpb.Duration
+// may still be too large to fit into a time.Duration (the range of durpb.Duration
+// is about 10,000 years, and the range of time.Duration is about 290).
+func validateDuration(d *durpb.Duration) error {
+	if d == nil {
+		return errors.New("duration: nil Duration")
+	}
+	if d.Seconds < minSeconds || d.Seconds > maxSeconds {
+		return fmt.Errorf("duration: %v: seconds out of range", d)
+	}
+	if d.Nanos <= -1e9 || d.Nanos >= 1e9 {
+		return fmt.Errorf("duration: %v: nanos out of range", d)
+	}
+	// Seconds and Nanos must have the same sign, unless d.Nanos is zero.
+	if (d.Seconds < 0 && d.Nanos > 0) || (d.Seconds > 0 && d.Nanos < 0) {
+		return fmt.Errorf("duration: %v: seconds and nanos have different signs", d)
+	}
+	return nil
+}
+
+// Duration converts a durpb.Duration to a time.Duration. Duration
+// returns an error if the durpb.Duration is invalid or is too large to be
+// represented in a time.Duration.
+func Duration(p *durpb.Duration) (time.Duration, error) {
+	if err := validateDuration(p); err != nil {
+		return 0, err
+	}
+	d := time.Duration(p.Seconds) * time.Second
+	if int64(d/time.Second) != p.Seconds {
+		return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p)
+	}
+	if p.Nanos != 0 {
+		d += time.Duration(p.Nanos)
+		if (d < 0) != (p.Nanos < 0) {
+			return 0, fmt.Errorf("duration: %v is out of range for time.Duration", p)
+		}
+	}
+	return d, nil
+}
+
+// DurationProto converts a time.Duration to a durpb.Duration.
+func DurationProto(d time.Duration) *durpb.Duration {
+	nanos := d.Nanoseconds()
+	secs := nanos / 1e9
+	nanos -= secs * 1e9
+	return &durpb.Duration{
+		Seconds: secs,
+		Nanos:   int32(nanos),
+	}
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go b/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
new file mode 100644
index 000000000..b2410a098
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/duration/duration.pb.go
@@ -0,0 +1,144 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/duration.proto
+
+/*
+Package duration is a generated protocol buffer package.
+
+It is generated from these files:
+	google/protobuf/duration.proto
+
+It has these top-level messages:
+	Duration
+*/
+package duration
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// A Duration represents a signed, fixed-length span of time represented
+// as a count of seconds and fractions of seconds at nanosecond
+// resolution. It is independent of any calendar and concepts like "day"
+// or "month". It is related to Timestamp in that the difference between
+// two Timestamp values is a Duration and it can be added or subtracted
+// from a Timestamp. Range is approximately +-10,000 years.
+//
+// # Examples
+//
+// Example 1: Compute Duration from two Timestamps in pseudo code.
+//
+//     Timestamp start = ...;
+//     Timestamp end = ...;
+//     Duration duration = ...;
+//
+//     duration.seconds = end.seconds - start.seconds;
+//     duration.nanos = end.nanos - start.nanos;
+//
+//     if (duration.seconds < 0 && duration.nanos > 0) {
+//       duration.seconds += 1;
+//       duration.nanos -= 1000000000;
+//     } else if (durations.seconds > 0 && duration.nanos < 0) {
+//       duration.seconds -= 1;
+//       duration.nanos += 1000000000;
+//     }
+//
+// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+//
+//     Timestamp start = ...;
+//     Duration duration = ...;
+//     Timestamp end = ...;
+//
+//     end.seconds = start.seconds + duration.seconds;
+//     end.nanos = start.nanos + duration.nanos;
+//
+//     if (end.nanos < 0) {
+//       end.seconds -= 1;
+//       end.nanos += 1000000000;
+//     } else if (end.nanos >= 1000000000) {
+//       end.seconds += 1;
+//       end.nanos -= 1000000000;
+//     }
+//
+// Example 3: Compute Duration from datetime.timedelta in Python.
+//
+//     td = datetime.timedelta(days=3, minutes=10)
+//     duration = Duration()
+//     duration.FromTimedelta(td)
+//
+// # JSON Mapping
+//
+// In JSON format, the Duration type is encoded as a string rather than an
+// object, where the string ends in the suffix "s" (indicating seconds) and
+// is preceded by the number of seconds, with nanoseconds expressed as
+// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+// microsecond should be expressed in JSON format as "3.000001s".
+//
+//
+type Duration struct {
+	// Signed seconds of the span of time. Must be from -315,576,000,000
+	// to +315,576,000,000 inclusive. Note: these bounds are computed from:
+	// 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+	Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"`
+	// Signed fractions of a second at nanosecond resolution of the span
+	// of time. Durations less than one second are represented with a 0
+	// `seconds` field and a positive or negative `nanos` field. For durations
+	// of one second or more, a non-zero value for the `nanos` field must be
+	// of the same sign as the `seconds` field. Must be from -999,999,999
+	// to +999,999,999 inclusive.
+	Nanos int32 `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"`
+}
+
+func (m *Duration) Reset()                    { *m = Duration{} }
+func (m *Duration) String() string            { return proto.CompactTextString(m) }
+func (*Duration) ProtoMessage()               {}
+func (*Duration) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+func (*Duration) XXX_WellKnownType() string   { return "Duration" }
+
+func (m *Duration) GetSeconds() int64 {
+	if m != nil {
+		return m.Seconds
+	}
+	return 0
+}
+
+func (m *Duration) GetNanos() int32 {
+	if m != nil {
+		return m.Nanos
+	}
+	return 0
+}
+
+func init() {
+	proto.RegisterType((*Duration)(nil), "google.protobuf.Duration")
+}
+
+func init() { proto.RegisterFile("google/protobuf/duration.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 190 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4b, 0xcf, 0xcf, 0x4f,
+	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x4f, 0x29, 0x2d, 0x4a,
+	0x2c, 0xc9, 0xcc, 0xcf, 0xd3, 0x03, 0x8b, 0x08, 0xf1, 0x43, 0xe4, 0xf5, 0x60, 0xf2, 0x4a, 0x56,
+	0x5c, 0x1c, 0x2e, 0x50, 0x25, 0x42, 0x12, 0x5c, 0xec, 0xc5, 0xa9, 0xc9, 0xf9, 0x79, 0x29, 0xc5,
+	0x12, 0x8c, 0x0a, 0x8c, 0x1a, 0xcc, 0x41, 0x30, 0xae, 0x90, 0x08, 0x17, 0x6b, 0x5e, 0x62, 0x5e,
+	0x7e, 0xb1, 0x04, 0x93, 0x02, 0xa3, 0x06, 0x6b, 0x10, 0x84, 0xe3, 0x54, 0xc3, 0x25, 0x9c, 0x9c,
+	0x9f, 0xab, 0x87, 0x66, 0xa4, 0x13, 0x2f, 0xcc, 0xc0, 0x00, 0x90, 0x48, 0x00, 0x63, 0x94, 0x56,
+	0x7a, 0x66, 0x49, 0x46, 0x69, 0x92, 0x5e, 0x72, 0x7e, 0xae, 0x7e, 0x7a, 0x7e, 0x4e, 0x62, 0x5e,
+	0x3a, 0xc2, 0x7d, 0x05, 0x25, 0x95, 0x05, 0xa9, 0xc5, 0x70, 0x67, 0xfe, 0x60, 0x64, 0x5c, 0xc4,
+	0xc4, 0xec, 0x1e, 0xe0, 0xb4, 0x8a, 0x49, 0xce, 0x1d, 0x62, 0x6e, 0x00, 0x54, 0xa9, 0x5e, 0x78,
+	0x6a, 0x4e, 0x8e, 0x77, 0x5e, 0x7e, 0x79, 0x5e, 0x08, 0x48, 0x4b, 0x12, 0x1b, 0xd8, 0x0c, 0x63,
+	0x40, 0x00, 0x00, 0x00, 0xff, 0xff, 0xdc, 0x84, 0x30, 0xff, 0xf3, 0x00, 0x00, 0x00,
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto b/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto
new file mode 100644
index 000000000..975fce41a
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/duration/duration.proto
@@ -0,0 +1,117 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "github.com/golang/protobuf/ptypes/duration";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "DurationProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// A Duration represents a signed, fixed-length span of time represented
+// as a count of seconds and fractions of seconds at nanosecond
+// resolution. It is independent of any calendar and concepts like "day"
+// or "month". It is related to Timestamp in that the difference between
+// two Timestamp values is a Duration and it can be added or subtracted
+// from a Timestamp. Range is approximately +-10,000 years.
+//
+// # Examples
+//
+// Example 1: Compute Duration from two Timestamps in pseudo code.
+//
+//     Timestamp start = ...;
+//     Timestamp end = ...;
+//     Duration duration = ...;
+//
+//     duration.seconds = end.seconds - start.seconds;
+//     duration.nanos = end.nanos - start.nanos;
+//
+//     if (duration.seconds < 0 && duration.nanos > 0) {
+//       duration.seconds += 1;
+//       duration.nanos -= 1000000000;
+//     } else if (durations.seconds > 0 && duration.nanos < 0) {
+//       duration.seconds -= 1;
+//       duration.nanos += 1000000000;
+//     }
+//
+// Example 2: Compute Timestamp from Timestamp + Duration in pseudo code.
+//
+//     Timestamp start = ...;
+//     Duration duration = ...;
+//     Timestamp end = ...;
+//
+//     end.seconds = start.seconds + duration.seconds;
+//     end.nanos = start.nanos + duration.nanos;
+//
+//     if (end.nanos < 0) {
+//       end.seconds -= 1;
+//       end.nanos += 1000000000;
+//     } else if (end.nanos >= 1000000000) {
+//       end.seconds += 1;
+//       end.nanos -= 1000000000;
+//     }
+//
+// Example 3: Compute Duration from datetime.timedelta in Python.
+//
+//     td = datetime.timedelta(days=3, minutes=10)
+//     duration = Duration()
+//     duration.FromTimedelta(td)
+//
+// # JSON Mapping
+//
+// In JSON format, the Duration type is encoded as a string rather than an
+// object, where the string ends in the suffix "s" (indicating seconds) and
+// is preceded by the number of seconds, with nanoseconds expressed as
+// fractional seconds. For example, 3 seconds with 0 nanoseconds should be
+// encoded in JSON format as "3s", while 3 seconds and 1 nanosecond should
+// be expressed in JSON format as "3.000000001s", and 3 seconds and 1
+// microsecond should be expressed in JSON format as "3.000001s".
+//
+//
+message Duration {
+
+  // Signed seconds of the span of time. Must be from -315,576,000,000
+  // to +315,576,000,000 inclusive. Note: these bounds are computed from:
+  // 60 sec/min * 60 min/hr * 24 hr/day * 365.25 days/year * 10000 years
+  int64 seconds = 1;
+
+  // Signed fractions of a second at nanosecond resolution of the span
+  // of time. Durations less than one second are represented with a 0
+  // `seconds` field and a positive or negative `nanos` field. For durations
+  // of one second or more, a non-zero value for the `nanos` field must be
+  // of the same sign as the `seconds` field. Must be from -999,999,999
+  // to +999,999,999 inclusive.
+  int32 nanos = 2;
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/regen.sh b/vendor/github.com/golang/protobuf/ptypes/regen.sh
new file mode 100755
index 000000000..b50a9414a
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/regen.sh
@@ -0,0 +1,43 @@
+#!/bin/bash -e
+#
+# This script fetches and rebuilds the "well-known types" protocol buffers.
+# To run this you will need protoc and goprotobuf installed;
+# see https://github.com/golang/protobuf for instructions.
+# You also need Go and Git installed.
+
+PKG=github.com/golang/protobuf/ptypes
+UPSTREAM=https://github.com/google/protobuf
+UPSTREAM_SUBDIR=src/google/protobuf
+PROTO_FILES=(any duration empty struct timestamp wrappers)
+
+function die() {
+  echo 1>&2 $*
+  exit 1
+}
+
+# Sanity check that the right tools are accessible.
+for tool in go git protoc protoc-gen-go; do
+  q=$(which $tool) || die "didn't find $tool"
+  echo 1>&2 "$tool: $q"
+done
+
+tmpdir=$(mktemp -d -t regen-wkt.XXXXXX)
+trap 'rm -rf $tmpdir' EXIT
+
+echo -n 1>&2 "finding package dir... "
+pkgdir=$(go list -f '{{.Dir}}' $PKG)
+echo 1>&2 $pkgdir
+base=$(echo $pkgdir | sed "s,/$PKG\$,,")
+echo 1>&2 "base: $base"
+cd "$base"
+
+echo 1>&2 "fetching latest protos... "
+git clone -q $UPSTREAM $tmpdir
+
+for file in ${PROTO_FILES[@]}; do
+  echo 1>&2 "* $file"
+  protoc --go_out=. -I$tmpdir/src $tmpdir/src/google/protobuf/$file.proto || die
+  cp $tmpdir/src/google/protobuf/$file.proto $PKG/$file
+done
+
+echo 1>&2 "All OK"
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp.go b/vendor/github.com/golang/protobuf/ptypes/timestamp.go
new file mode 100644
index 000000000..47f10dbc2
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp.go
@@ -0,0 +1,134 @@
+// Go support for Protocol Buffers - Google's data interchange format
+//
+// Copyright 2016 The Go Authors.  All rights reserved.
+// https://github.com/golang/protobuf
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+package ptypes
+
+// This file implements operations on google.protobuf.Timestamp.
+
+import (
+	"errors"
+	"fmt"
+	"time"
+
+	tspb "github.com/golang/protobuf/ptypes/timestamp"
+)
+
+const (
+	// Seconds field of the earliest valid Timestamp.
+	// This is time.Date(1, 1, 1, 0, 0, 0, 0, time.UTC).Unix().
+	minValidSeconds = -62135596800
+	// Seconds field just after the latest valid Timestamp.
+	// This is time.Date(10000, 1, 1, 0, 0, 0, 0, time.UTC).Unix().
+	maxValidSeconds = 253402300800
+)
+
+// validateTimestamp determines whether a Timestamp is valid.
+// A valid timestamp represents a time in the range
+// [0001-01-01, 10000-01-01) and has a Nanos field
+// in the range [0, 1e9).
+//
+// If the Timestamp is valid, validateTimestamp returns nil.
+// Otherwise, it returns an error that describes
+// the problem.
+//
+// Every valid Timestamp can be represented by a time.Time, but the converse is not true.
+func validateTimestamp(ts *tspb.Timestamp) error {
+	if ts == nil {
+		return errors.New("timestamp: nil Timestamp")
+	}
+	if ts.Seconds < minValidSeconds {
+		return fmt.Errorf("timestamp: %v before 0001-01-01", ts)
+	}
+	if ts.Seconds >= maxValidSeconds {
+		return fmt.Errorf("timestamp: %v after 10000-01-01", ts)
+	}
+	if ts.Nanos < 0 || ts.Nanos >= 1e9 {
+		return fmt.Errorf("timestamp: %v: nanos not in range [0, 1e9)", ts)
+	}
+	return nil
+}
+
+// Timestamp converts a google.protobuf.Timestamp proto to a time.Time.
+// It returns an error if the argument is invalid.
+//
+// Unlike most Go functions, if Timestamp returns an error, the first return value
+// is not the zero time.Time. Instead, it is the value obtained from the
+// time.Unix function when passed the contents of the Timestamp, in the UTC
+// locale. This may or may not be a meaningful time; many invalid Timestamps
+// do map to valid time.Times.
+//
+// A nil Timestamp returns an error. The first return value in that case is
+// undefined.
+func Timestamp(ts *tspb.Timestamp) (time.Time, error) {
+	// Don't return the zero value on error, because corresponds to a valid
+	// timestamp. Instead return whatever time.Unix gives us.
+	var t time.Time
+	if ts == nil {
+		t = time.Unix(0, 0).UTC() // treat nil like the empty Timestamp
+	} else {
+		t = time.Unix(ts.Seconds, int64(ts.Nanos)).UTC()
+	}
+	return t, validateTimestamp(ts)
+}
+
+// TimestampNow returns a google.protobuf.Timestamp for the current time.
+func TimestampNow() *tspb.Timestamp {
+	ts, err := TimestampProto(time.Now())
+	if err != nil {
+		panic("ptypes: time.Now() out of Timestamp range")
+	}
+	return ts
+}
+
+// TimestampProto converts the time.Time to a google.protobuf.Timestamp proto.
+// It returns an error if the resulting Timestamp is invalid.
+func TimestampProto(t time.Time) (*tspb.Timestamp, error) {
+	seconds := t.Unix()
+	nanos := int32(t.Sub(time.Unix(seconds, 0)))
+	ts := &tspb.Timestamp{
+		Seconds: seconds,
+		Nanos:   nanos,
+	}
+	if err := validateTimestamp(ts); err != nil {
+		return nil, err
+	}
+	return ts, nil
+}
+
+// TimestampString returns the RFC 3339 string for valid Timestamps. For invalid
+// Timestamps, it returns an error message in parentheses.
+func TimestampString(ts *tspb.Timestamp) string {
+	t, err := Timestamp(ts)
+	if err != nil {
+		return fmt.Sprintf("(%v)", err)
+	}
+	return t.Format(time.RFC3339Nano)
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
new file mode 100644
index 000000000..e23e4a25d
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.pb.go
@@ -0,0 +1,160 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/protobuf/timestamp.proto
+
+/*
+Package timestamp is a generated protocol buffer package.
+
+It is generated from these files:
+	google/protobuf/timestamp.proto
+
+It has these top-level messages:
+	Timestamp
+*/
+package timestamp
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// A Timestamp represents a point in time independent of any time zone
+// or calendar, represented as seconds and fractions of seconds at
+// nanosecond resolution in UTC Epoch time. It is encoded using the
+// Proleptic Gregorian Calendar which extends the Gregorian calendar
+// backwards to year one. It is encoded assuming all minutes are 60
+// seconds long, i.e. leap seconds are "smeared" so that no leap second
+// table is needed for interpretation. Range is from
+// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
+// By restricting to that range, we ensure that we can convert to
+// and from  RFC 3339 date strings.
+// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
+//
+// # Examples
+//
+// Example 1: Compute Timestamp from POSIX `time()`.
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(time(NULL));
+//     timestamp.set_nanos(0);
+//
+// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+//
+//     struct timeval tv;
+//     gettimeofday(&tv, NULL);
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(tv.tv_sec);
+//     timestamp.set_nanos(tv.tv_usec * 1000);
+//
+// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+//
+//     FILETIME ft;
+//     GetSystemTimeAsFileTime(&ft);
+//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+//
+//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+//     Timestamp timestamp;
+//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+//
+// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+//
+//     long millis = System.currentTimeMillis();
+//
+//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+//         .setNanos((int) ((millis % 1000) * 1000000)).build();
+//
+//
+// Example 5: Compute Timestamp from current time in Python.
+//
+//     timestamp = Timestamp()
+//     timestamp.GetCurrentTime()
+//
+// # JSON Mapping
+//
+// In JSON format, the Timestamp type is encoded as a string in the
+// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+// where {year} is always expressed using four digits while {month}, {day},
+// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+// is required, though only UTC (as indicated by "Z") is presently supported.
+//
+// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+// 01:30 UTC on January 15, 2017.
+//
+// In JavaScript, one can convert a Date object to this format using the
+// standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString]
+// method. In Python, a standard `datetime.datetime` object can be converted
+// to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
+// with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one
+// can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
+// http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime())
+// to obtain a formatter capable of generating timestamps in this format.
+//
+//
+type Timestamp struct {
+	// Represents seconds of UTC time since Unix epoch
+	// 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+	// 9999-12-31T23:59:59Z inclusive.
+	Seconds int64 `protobuf:"varint,1,opt,name=seconds" json:"seconds,omitempty"`
+	// Non-negative fractions of a second at nanosecond resolution. Negative
+	// second values with fractions must still have non-negative nanos values
+	// that count forward in time. Must be from 0 to 999,999,999
+	// inclusive.
+	Nanos int32 `protobuf:"varint,2,opt,name=nanos" json:"nanos,omitempty"`
+}
+
+func (m *Timestamp) Reset()                    { *m = Timestamp{} }
+func (m *Timestamp) String() string            { return proto.CompactTextString(m) }
+func (*Timestamp) ProtoMessage()               {}
+func (*Timestamp) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+func (*Timestamp) XXX_WellKnownType() string   { return "Timestamp" }
+
+func (m *Timestamp) GetSeconds() int64 {
+	if m != nil {
+		return m.Seconds
+	}
+	return 0
+}
+
+func (m *Timestamp) GetNanos() int32 {
+	if m != nil {
+		return m.Nanos
+	}
+	return 0
+}
+
+func init() {
+	proto.RegisterType((*Timestamp)(nil), "google.protobuf.Timestamp")
+}
+
+func init() { proto.RegisterFile("google/protobuf/timestamp.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 191 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4f, 0xcf, 0xcf, 0x4f,
+	0xcf, 0x49, 0xd5, 0x2f, 0x28, 0xca, 0x2f, 0xc9, 0x4f, 0x2a, 0x4d, 0xd3, 0x2f, 0xc9, 0xcc, 0x4d,
+	0x2d, 0x2e, 0x49, 0xcc, 0x2d, 0xd0, 0x03, 0x0b, 0x09, 0xf1, 0x43, 0x14, 0xe8, 0xc1, 0x14, 0x28,
+	0x59, 0x73, 0x71, 0x86, 0xc0, 0xd4, 0x08, 0x49, 0x70, 0xb1, 0x17, 0xa7, 0x26, 0xe7, 0xe7, 0xa5,
+	0x14, 0x4b, 0x30, 0x2a, 0x30, 0x6a, 0x30, 0x07, 0xc1, 0xb8, 0x42, 0x22, 0x5c, 0xac, 0x79, 0x89,
+	0x79, 0xf9, 0xc5, 0x12, 0x4c, 0x0a, 0x8c, 0x1a, 0xac, 0x41, 0x10, 0x8e, 0x53, 0x1d, 0x97, 0x70,
+	0x72, 0x7e, 0xae, 0x1e, 0x9a, 0x99, 0x4e, 0x7c, 0x70, 0x13, 0x03, 0x40, 0x42, 0x01, 0x8c, 0x51,
+	0xda, 0xe9, 0x99, 0x25, 0x19, 0xa5, 0x49, 0x7a, 0xc9, 0xf9, 0xb9, 0xfa, 0xe9, 0xf9, 0x39, 0x89,
+	0x79, 0xe9, 0x08, 0x27, 0x16, 0x94, 0x54, 0x16, 0xa4, 0x16, 0x23, 0x5c, 0xfa, 0x83, 0x91, 0x71,
+	0x11, 0x13, 0xb3, 0x7b, 0x80, 0xd3, 0x2a, 0x26, 0x39, 0x77, 0x88, 0xc9, 0x01, 0x50, 0xb5, 0x7a,
+	0xe1, 0xa9, 0x39, 0x39, 0xde, 0x79, 0xf9, 0xe5, 0x79, 0x21, 0x20, 0x3d, 0x49, 0x6c, 0x60, 0x43,
+	0x8c, 0x01, 0x01, 0x00, 0x00, 0xff, 0xff, 0xbc, 0x77, 0x4a, 0x07, 0xf7, 0x00, 0x00, 0x00,
+}
diff --git a/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
new file mode 100644
index 000000000..b7cbd1750
--- /dev/null
+++ b/vendor/github.com/golang/protobuf/ptypes/timestamp/timestamp.proto
@@ -0,0 +1,133 @@
+// Protocol Buffers - Google's data interchange format
+// Copyright 2008 Google Inc.  All rights reserved.
+// https://developers.google.com/protocol-buffers/
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+syntax = "proto3";
+
+package google.protobuf;
+
+option csharp_namespace = "Google.Protobuf.WellKnownTypes";
+option cc_enable_arenas = true;
+option go_package = "github.com/golang/protobuf/ptypes/timestamp";
+option java_package = "com.google.protobuf";
+option java_outer_classname = "TimestampProto";
+option java_multiple_files = true;
+option objc_class_prefix = "GPB";
+
+// A Timestamp represents a point in time independent of any time zone
+// or calendar, represented as seconds and fractions of seconds at
+// nanosecond resolution in UTC Epoch time. It is encoded using the
+// Proleptic Gregorian Calendar which extends the Gregorian calendar
+// backwards to year one. It is encoded assuming all minutes are 60
+// seconds long, i.e. leap seconds are "smeared" so that no leap second
+// table is needed for interpretation. Range is from
+// 0001-01-01T00:00:00Z to 9999-12-31T23:59:59.999999999Z.
+// By restricting to that range, we ensure that we can convert to
+// and from  RFC 3339 date strings.
+// See [https://www.ietf.org/rfc/rfc3339.txt](https://www.ietf.org/rfc/rfc3339.txt).
+//
+// # Examples
+//
+// Example 1: Compute Timestamp from POSIX `time()`.
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(time(NULL));
+//     timestamp.set_nanos(0);
+//
+// Example 2: Compute Timestamp from POSIX `gettimeofday()`.
+//
+//     struct timeval tv;
+//     gettimeofday(&tv, NULL);
+//
+//     Timestamp timestamp;
+//     timestamp.set_seconds(tv.tv_sec);
+//     timestamp.set_nanos(tv.tv_usec * 1000);
+//
+// Example 3: Compute Timestamp from Win32 `GetSystemTimeAsFileTime()`.
+//
+//     FILETIME ft;
+//     GetSystemTimeAsFileTime(&ft);
+//     UINT64 ticks = (((UINT64)ft.dwHighDateTime) << 32) | ft.dwLowDateTime;
+//
+//     // A Windows tick is 100 nanoseconds. Windows epoch 1601-01-01T00:00:00Z
+//     // is 11644473600 seconds before Unix epoch 1970-01-01T00:00:00Z.
+//     Timestamp timestamp;
+//     timestamp.set_seconds((INT64) ((ticks / 10000000) - 11644473600LL));
+//     timestamp.set_nanos((INT32) ((ticks % 10000000) * 100));
+//
+// Example 4: Compute Timestamp from Java `System.currentTimeMillis()`.
+//
+//     long millis = System.currentTimeMillis();
+//
+//     Timestamp timestamp = Timestamp.newBuilder().setSeconds(millis / 1000)
+//         .setNanos((int) ((millis % 1000) * 1000000)).build();
+//
+//
+// Example 5: Compute Timestamp from current time in Python.
+//
+//     timestamp = Timestamp()
+//     timestamp.GetCurrentTime()
+//
+// # JSON Mapping
+//
+// In JSON format, the Timestamp type is encoded as a string in the
+// [RFC 3339](https://www.ietf.org/rfc/rfc3339.txt) format. That is, the
+// format is "{year}-{month}-{day}T{hour}:{min}:{sec}[.{frac_sec}]Z"
+// where {year} is always expressed using four digits while {month}, {day},
+// {hour}, {min}, and {sec} are zero-padded to two digits each. The fractional
+// seconds, which can go up to 9 digits (i.e. up to 1 nanosecond resolution),
+// are optional. The "Z" suffix indicates the timezone ("UTC"); the timezone
+// is required, though only UTC (as indicated by "Z") is presently supported.
+//
+// For example, "2017-01-15T01:30:15.01Z" encodes 15.01 seconds past
+// 01:30 UTC on January 15, 2017.
+//
+// In JavaScript, one can convert a Date object to this format using the
+// standard [toISOString()](https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Date/toISOString]
+// method. In Python, a standard `datetime.datetime` object can be converted
+// to this format using [`strftime`](https://docs.python.org/2/library/time.html#time.strftime)
+// with the time format spec '%Y-%m-%dT%H:%M:%S.%fZ'. Likewise, in Java, one
+// can use the Joda Time's [`ISODateTimeFormat.dateTime()`](
+// http://joda-time.sourceforge.net/apidocs/org/joda/time/format/ISODateTimeFormat.html#dateTime())
+// to obtain a formatter capable of generating timestamps in this format.
+//
+//
+message Timestamp {
+
+  // Represents seconds of UTC time since Unix epoch
+  // 1970-01-01T00:00:00Z. Must be from 0001-01-01T00:00:00Z to
+  // 9999-12-31T23:59:59Z inclusive.
+  int64 seconds = 1;
+
+  // Non-negative fractions of a second at nanosecond resolution. Negative
+  // second values with fractions must still have non-negative nanos values
+  // that count forward in time. Must be from 0 to 999,999,999
+  // inclusive.
+  int32 nanos = 2;
+}
diff --git a/vendor/github.com/hashicorp/go-hclog/LICENSE b/vendor/github.com/hashicorp/go-hclog/LICENSE
new file mode 100644
index 000000000..abaf1e45f
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-hclog/LICENSE
@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2017 HashiCorp
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.
diff --git a/vendor/github.com/hashicorp/go-hclog/README.md b/vendor/github.com/hashicorp/go-hclog/README.md
new file mode 100644
index 000000000..614342b2d
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-hclog/README.md
@@ -0,0 +1,123 @@
+# go-hclog
+
+[![Go Documentation](http://img.shields.io/badge/go-documentation-blue.svg?style=flat-square)][godocs]
+
+[godocs]: https://godoc.org/github.com/hashicorp/go-hclog
+
+`go-hclog` is a package for Go that provides a simple key/value logging
+interface for use in development and production environments.
+
+It provides logging levels that provide decreased output based upon the
+desired amount of output, unlike the standard library `log` package.
+
+It does not provide `Printf` style logging, only key/value logging that is
+exposed as arguments to the logging functions for simplicity.
+
+It provides a human readable output mode for use in development as well as
+JSON output mode for production.
+
+## Stability Note
+
+While this library is fully open source and HashiCorp will be maintaining it
+(since we are and will be making extensive use of it), the API and output
+format is subject to minor changes as we fully bake and vet it in our projects.
+This notice will be removed once it's fully integrated into our major projects
+and no further changes are anticipated.
+
+## Installation and Docs
+
+Install using `go get github.com/hashicorp/go-hclog`.
+
+Full documentation is available at
+http://godoc.org/github.com/hashicorp/go-hclog
+
+## Usage
+
+### Use the global logger
+
+```go
+hclog.Default().Info("hello world")
+```
+
+```text
+2017-07-05T16:15:55.167-0700 [INFO ] hello world
+```
+
+(Note timestamps are removed in future examples for brevity.)
+
+### Create a new logger
+
+```go
+appLogger := hclog.New(&hclog.LoggerOptions{
+	Name:  "my-app",
+	Level: hclog.LevelFromString("DEBUG"),
+})
+```
+
+### Emit an Info level message with 2 key/value pairs
+
+```go
+input := "5.5"
+_, err := strconv.ParseInt(input, 10, 32)
+if err != nil {
+	appLogger.Info("Invalid input for ParseInt", "input", input, "error", err)
+}
+```
+
+```text
+... [INFO ] my-app: Invalid input for ParseInt: input=5.5 error="strconv.ParseInt: parsing "5.5": invalid syntax"
+```
+
+### Create a new Logger for a major subsystem
+
+```go
+subsystemLogger := appLogger.Named("transport")
+subsystemLogger.Info("we are transporting something")
+```
+
+```text
+... [INFO ] my-app.transport: we are transporting something
+```
+
+Notice that logs emitted by `subsystemLogger` contain `my-app.transport`,
+reflecting both the application and subsystem names.
+
+### Create a new Logger with fixed key/value pairs
+
+Using `With()` will include a specific key-value pair in all messages emitted
+by that logger.
+
+```go
+requestID := "5fb446b6-6eba-821d-df1b-cd7501b6a363"
+requestLogger := subsystemLogger.With("request", requestID)
+requestLogger.Info("we are transporting a request")
+```
+
+```text
+... [INFO ] my-app.transport: we are transporting a request: request=5fb446b6-6eba-821d-df1b-cd7501b6a363
+```
+
+This allows sub Loggers to be context specific without having to thread that
+into all the callers.
+
+### Use this with code that uses the standard library logger
+
+If you want to use the standard library's `log.Logger` interface you can wrap
+`hclog.Logger` by calling the `StandardLogger()` method. This allows you to use
+it with the familiar `Println()`, `Printf()`, etc. For example:
+
+```go
+stdLogger := appLogger.StandardLogger(&hclog.StandardLoggerOptions{
+	InferLevels: true,
+})
+// Printf() is provided by stdlib log.Logger interface, not hclog.Logger
+stdLogger.Printf("[DEBUG] %+v", stdLogger)
+```
+
+```text
+... [DEBUG] my-app: &{mu:{state:0 sema:0} prefix: flag:0 out:0xc42000a0a0 buf:[]}
+```
+
+Notice that if `appLogger` is initialized with the `INFO` log level _and_ you
+specify `InferLevels: true`, you will not see any output here. You must change
+`appLogger` to `DEBUG` to see output. See the docs for more information.
diff --git a/vendor/github.com/hashicorp/go-hclog/global.go b/vendor/github.com/hashicorp/go-hclog/global.go
new file mode 100644
index 000000000..55ce43960
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-hclog/global.go
@@ -0,0 +1,34 @@
+package hclog
+
+import (
+	"sync"
+)
+
+var (
+	protect sync.Once
+	def     Logger
+
+	// The options used to create the Default logger. These are
+	// read only when the Default logger is created, so set them
+	// as soon as the process starts.
+	DefaultOptions = &LoggerOptions{
+		Level:  DefaultLevel,
+		Output: DefaultOutput,
+	}
+)
+
+// Return a logger that is held globally. This can be a good starting
+// place, and then you can use .With() and .Name() to create sub-loggers
+// to be used in more specific contexts.
+func Default() Logger {
+	protect.Do(func() {
+		def = New(DefaultOptions)
+	})
+
+	return def
+}
+
+// A short alias for Default()
+func L() Logger {
+	return Default()
+}
diff --git a/vendor/github.com/hashicorp/go-hclog/int.go b/vendor/github.com/hashicorp/go-hclog/int.go
new file mode 100644
index 000000000..20adcfbb9
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-hclog/int.go
@@ -0,0 +1,404 @@
+package hclog
+
+import (
+	"bufio"
+	"encoding"
+	"encoding/json"
+	"fmt"
+	"log"
+	"os"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+)
+
+var (
+	_levelToBracket = map[Level]string{
+		Debug: "[DEBUG]",
+		Trace: "[TRACE]",
+		Info:  "[INFO ]",
+		Warn:  "[WARN ]",
+		Error: "[ERROR]",
+	}
+)
+
+// Given the options (nil for defaults), create a new Logger
+func New(opts *LoggerOptions) Logger {
+	if opts == nil {
+		opts = &LoggerOptions{}
+	}
+
+	output := opts.Output
+	if output == nil {
+		output = os.Stderr
+	}
+
+	level := opts.Level
+	if level == NoLevel {
+		level = DefaultLevel
+	}
+
+	mtx := opts.Mutex
+	if mtx == nil {
+		mtx = new(sync.Mutex)
+	}
+
+	return &intLogger{
+		m:      mtx,
+		json:   opts.JSONFormat,
+		caller: opts.IncludeLocation,
+		name:   opts.Name,
+		w:      bufio.NewWriter(output),
+		level:  level,
+	}
+}
+
+// The internal logger implementation. Internal in that it is defined entirely
+// by this package.
+type intLogger struct {
+	json   bool
+	caller bool
+	name   string
+
+	// this is a pointer so that it's shared by any derived loggers, since
+	// those derived loggers share the bufio.Writer as well.
+	m     *sync.Mutex
+	w     *bufio.Writer
+	level Level
+
+	implied []interface{}
+}
+
+// Make sure that intLogger is a Logger
+var _ Logger = &intLogger{}
+
+// The time format to use for logging. This is a version of RFC3339 that
+// contains millisecond precision
+const TimeFormat = "2006-01-02T15:04:05.000Z0700"
+
+// Log a message and a set of key/value pairs if the given level is at
+// or more severe that the threshold configured in the Logger.
+func (z *intLogger) Log(level Level, msg string, args ...interface{}) {
+	if level < z.level {
+		return
+	}
+
+	t := time.Now()
+
+	z.m.Lock()
+	defer z.m.Unlock()
+
+	if z.json {
+		z.logJson(t, level, msg, args...)
+	} else {
+		z.log(t, level, msg, args...)
+	}
+
+	z.w.Flush()
+}
+
+// Cleanup a path by returning the last 2 segments of the path only.
+func trimCallerPath(path string) string {
+	// lovely borrowed from zap
+	// nb. To make sure we trim the path correctly on Windows too, we
+	// counter-intuitively need to use '/' and *not* os.PathSeparator here,
+	// because the path given originates from Go stdlib, specifically
+	// runtime.Caller() which (as of Mar/17) returns forward slashes even on
+	// Windows.
+	//
+	// See https://github.com/golang/go/issues/3335
+	// and https://github.com/golang/go/issues/18151
+	//
+	// for discussion on the issue on Go side.
+	//
+
+	// Find the last separator.
+	//
+	idx := strings.LastIndexByte(path, '/')
+	if idx == -1 {
+		return path
+	}
+
+	// Find the penultimate separator.
+	idx = strings.LastIndexByte(path[:idx], '/')
+	if idx == -1 {
+		return path
+	}
+
+	return path[idx+1:]
+}
+
+// Non-JSON logging format function
+func (z *intLogger) log(t time.Time, level Level, msg string, args ...interface{}) {
+	z.w.WriteString(t.Format(TimeFormat))
+	z.w.WriteByte(' ')
+
+	s, ok := _levelToBracket[level]
+	if ok {
+		z.w.WriteString(s)
+	} else {
+		z.w.WriteString("[UNKN ]")
+	}
+
+	if z.caller {
+		if _, file, line, ok := runtime.Caller(3); ok {
+			z.w.WriteByte(' ')
+			z.w.WriteString(trimCallerPath(file))
+			z.w.WriteByte(':')
+			z.w.WriteString(strconv.Itoa(line))
+			z.w.WriteByte(':')
+		}
+	}
+
+	z.w.WriteByte(' ')
+
+	if z.name != "" {
+		z.w.WriteString(z.name)
+		z.w.WriteString(": ")
+	}
+
+	z.w.WriteString(msg)
+
+	args = append(z.implied, args...)
+
+	var stacktrace CapturedStacktrace
+
+	if args != nil && len(args) > 0 {
+		if len(args)%2 != 0 {
+			cs, ok := args[len(args)-1].(CapturedStacktrace)
+			if ok {
+				args = args[:len(args)-1]
+				stacktrace = cs
+			} else {
+				args = append(args, "<unknown>")
+			}
+		}
+
+		z.w.WriteByte(':')
+
+	FOR:
+		for i := 0; i < len(args); i = i + 2 {
+			var val string
+
+			switch st := args[i+1].(type) {
+			case string:
+				val = st
+			case int:
+				val = strconv.FormatInt(int64(st), 10)
+			case int64:
+				val = strconv.FormatInt(int64(st), 10)
+			case int32:
+				val = strconv.FormatInt(int64(st), 10)
+			case int16:
+				val = strconv.FormatInt(int64(st), 10)
+			case int8:
+				val = strconv.FormatInt(int64(st), 10)
+			case uint:
+				val = strconv.FormatUint(uint64(st), 10)
+			case uint64:
+				val = strconv.FormatUint(uint64(st), 10)
+			case uint32:
+				val = strconv.FormatUint(uint64(st), 10)
+			case uint16:
+				val = strconv.FormatUint(uint64(st), 10)
+			case uint8:
+				val = strconv.FormatUint(uint64(st), 10)
+			case CapturedStacktrace:
+				stacktrace = st
+				continue FOR
+			default:
+				val = fmt.Sprintf("%v", st)
+			}
+
+			z.w.WriteByte(' ')
+			z.w.WriteString(args[i].(string))
+			z.w.WriteByte('=')
+
+			if strings.ContainsAny(val, " \t\n\r") {
+				z.w.WriteByte('"')
+				z.w.WriteString(val)
+				z.w.WriteByte('"')
+			} else {
+				z.w.WriteString(val)
+			}
+		}
+	}
+
+	z.w.WriteString("\n")
+
+	if stacktrace != "" {
+		z.w.WriteString(string(stacktrace))
+	}
+}
+
+// JSON logging function
+func (z *intLogger) logJson(t time.Time, level Level, msg string, args ...interface{}) {
+	vals := map[string]interface{}{
+		"@message":   msg,
+		"@timestamp": t.Format("2006-01-02T15:04:05.000000Z07:00"),
+	}
+
+	var levelStr string
+	switch level {
+	case Error:
+		levelStr = "error"
+	case Warn:
+		levelStr = "warn"
+	case Info:
+		levelStr = "info"
+	case Debug:
+		levelStr = "debug"
+	case Trace:
+		levelStr = "trace"
+	default:
+		levelStr = "all"
+	}
+
+	vals["@level"] = levelStr
+
+	if z.name != "" {
+		vals["@module"] = z.name
+	}
+
+	if z.caller {
+		if _, file, line, ok := runtime.Caller(3); ok {
+			vals["@caller"] = fmt.Sprintf("%s:%d", file, line)
+		}
+	}
+
+	if args != nil && len(args) > 0 {
+		if len(args)%2 != 0 {
+			cs, ok := args[len(args)-1].(CapturedStacktrace)
+			if ok {
+				args = args[:len(args)-1]
+				vals["stacktrace"] = cs
+			} else {
+				args = append(args, "<unknown>")
+			}
+		}
+
+		for i := 0; i < len(args); i = i + 2 {
+			if _, ok := args[i].(string); !ok {
+				// As this is the logging function not much we can do here
+				// without injecting into logs...
+				continue
+			}
+			val := args[i+1]
+			// Check if val is of type error. If error type doesn't
+			// implement json.Marshaler or encoding.TextMarshaler
+			// then set val to err.Error() so that it gets marshaled
+			if err, ok := val.(error); ok {
+				switch err.(type) {
+				case json.Marshaler, encoding.TextMarshaler:
+				default:
+					val = err.Error()
+				}
+			}
+			vals[args[i].(string)] = val
+		}
+	}
+
+	err := json.NewEncoder(z.w).Encode(vals)
+	if err != nil {
+		panic(err)
+	}
+}
+
+// Emit the message and args at DEBUG level
+func (z *intLogger) Debug(msg string, args ...interface{}) {
+	z.Log(Debug, msg, args...)
+}
+
+// Emit the message and args at TRACE level
+func (z *intLogger) Trace(msg string, args ...interface{}) {
+	z.Log(Trace, msg, args...)
+}
+
+// Emit the message and args at INFO level
+func (z *intLogger) Info(msg string, args ...interface{}) {
+	z.Log(Info, msg, args...)
+}
+
+// Emit the message and args at WARN level
+func (z *intLogger) Warn(msg string, args ...interface{}) {
+	z.Log(Warn, msg, args...)
+}
+
+// Emit the message and args at ERROR level
+func (z *intLogger) Error(msg string, args ...interface{}) {
+	z.Log(Error, msg, args...)
+}
+
+// Indicate that the logger would emit TRACE level logs
+func (z *intLogger) IsTrace() bool {
+	return z.level == Trace
+}
+
+// Indicate that the logger would emit DEBUG level logs
+func (z *intLogger) IsDebug() bool {
+	return z.level <= Debug
+}
+
+// Indicate that the logger would emit INFO level logs
+func (z *intLogger) IsInfo() bool {
+	return z.level <= Info
+}
+
+// Indicate that the logger would emit WARN level logs
+func (z *intLogger) IsWarn() bool {
+	return z.level <= Warn
+}
+
+// Indicate that the logger would emit ERROR level logs
+func (z *intLogger) IsError() bool {
+	return z.level <= Error
+}
+
+// Return a sub-Logger for which every emitted log message will contain
+// the given key/value pairs. This is used to create a context specific
+// Logger.
+func (z *intLogger) With(args ...interface{}) Logger {
+	var nz intLogger = *z
+
+	nz.implied = append(nz.implied, args...)
+
+	return &nz
+}
+
+// Create a new sub-Logger that a name decending from the current name.
+// This is used to create a subsystem specific Logger.
+func (z *intLogger) Named(name string) Logger {
+	var nz intLogger = *z
+
+	if nz.name != "" {
+		nz.name = nz.name + "." + name
+	} else {
+		nz.name = name
+	}
+
+	return &nz
+}
+
+// Create a new sub-Logger with an explicit name. This ignores the current
+// name. This is used to create a standalone logger that doesn't fall
+// within the normal hierarchy.
+func (z *intLogger) ResetNamed(name string) Logger {
+	var nz intLogger = *z
+
+	nz.name = name
+
+	return &nz
+}
+
+// Create a *log.Logger that will send it's data through this Logger. This
+// allows packages that expect to be using the standard library log to actually
+// use this logger.
+func (z *intLogger) StandardLogger(opts *StandardLoggerOptions) *log.Logger {
+	if opts == nil {
+		opts = &StandardLoggerOptions{}
+	}
+
+	return log.New(&stdlogAdapter{z, opts.InferLevels}, "", 0)
+}
diff --git a/vendor/github.com/hashicorp/go-hclog/log.go b/vendor/github.com/hashicorp/go-hclog/log.go
new file mode 100644
index 000000000..dbc4198a5
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-hclog/log.go
@@ -0,0 +1,142 @@
+package hclog
+
+import (
+	"io"
+	"log"
+	"os"
+	"strings"
+	"sync"
+)
+
+var (
+	DefaultOutput = os.Stderr
+	DefaultLevel  = Info
+)
+
+type Level int
+
+const (
+	// This is a special level used to indicate that no level has been
+	// set and allow for a default to be used.
+	NoLevel Level = 0
+
+	// The most verbose level. Intended to be used for the tracing of actions
+	// in code, such as function enters/exits, etc.
+	Trace Level = 1
+
+	// For programmer lowlevel analysis.
+	Debug Level = 2
+
+	// For information about steady state operations.
+	Info Level = 3
+
+	// For information about rare but handled events.
+	Warn Level = 4
+
+	// For information about unrecoverable events.
+	Error Level = 5
+)
+
+// LevelFromString returns a Level type for the named log level, or "NoLevel" if
+// the level string is invalid. This facilitates setting the log level via
+// config or environment variable by name in a predictable way.
+func LevelFromString(levelStr string) Level {
+	// We don't care about case. Accept "INFO" or "info"
+	levelStr = strings.ToLower(strings.TrimSpace(levelStr))
+	switch levelStr {
+	case "trace":
+		return Trace
+	case "debug":
+		return Debug
+	case "info":
+		return Info
+	case "warn":
+		return Warn
+	case "error":
+		return Error
+	default:
+		return NoLevel
+	}
+}
+
+// The main Logger interface. All code should code against this interface only.
+type Logger interface {
+	// Args are alternating key, val pairs
+	// keys must be strings
+	// vals can be any type, but display is implementation specific
+	// Emit a message and key/value pairs at the TRACE level
+	Trace(msg string, args ...interface{})
+
+	// Emit a message and key/value pairs at the DEBUG level
+	Debug(msg string, args ...interface{})
+
+	// Emit a message and key/value pairs at the INFO level
+	Info(msg string, args ...interface{})
+
+	// Emit a message and key/value pairs at the WARN level
+	Warn(msg string, args ...interface{})
+
+	// Emit a message and key/value pairs at the ERROR level
+	Error(msg string, args ...interface{})
+
+	// Indicate if TRACE logs would be emitted. This and the other Is* guards
+	// are used to elide expensive logging code based on the current level.
+	IsTrace() bool
+
+	// Indicate if DEBUG logs would be emitted. This and the other Is* guards
+	IsDebug() bool
+
+	// Indicate if INFO logs would be emitted. This and the other Is* guards
+	IsInfo() bool
+
+	// Indicate if WARN logs would be emitted. This and the other Is* guards
+	IsWarn() bool
+
+	// Indicate if ERROR logs would be emitted. This and the other Is* guards
+	IsError() bool
+
+	// Creates a sublogger that will always have the given key/value pairs
+	With(args ...interface{}) Logger
+
+	// Create a logger that will prepend the name string on the front of all messages.
+	// If the logger already has a name, the new value will be appended to the current
+	// name. That way, a major subsystem can use this to decorate all it's own logs
+	// without losing context.
+	Named(name string) Logger
+
+	// Create a logger that will prepend the name string on the front of all messages.
+	// This sets the name of the logger to the value directly, unlike Named which honor
+	// the current name as well.
+	ResetNamed(name string) Logger
+
+	// Return a value that conforms to the stdlib log.Logger interface
+	StandardLogger(opts *StandardLoggerOptions) *log.Logger
+}
+
+type StandardLoggerOptions struct {
+	// Indicate that some minimal parsing should be done on strings to try
+	// and detect their level and re-emit them.
+	// This supports the strings like [ERROR], [ERR] [TRACE], [WARN], [INFO],
+	// [DEBUG] and strip it off before reapplying it.
+	InferLevels bool
+}
+
+type LoggerOptions struct {
+	// Name of the subsystem to prefix logs with
+	Name string
+
+	// The threshold for the logger. Anything less severe is supressed
+	Level Level
+
+	// Where to write the logs to. Defaults to os.Stdout if nil
+	Output io.Writer
+
+	// An optional mutex pointer in case Output is shared
+	Mutex *sync.Mutex
+
+	// Control if the output should be in JSON.
+	JSONFormat bool
+
+	// Include file and line information in each log line
+	IncludeLocation bool
+}
diff --git a/vendor/github.com/hashicorp/go-hclog/stacktrace.go b/vendor/github.com/hashicorp/go-hclog/stacktrace.go
new file mode 100644
index 000000000..8af1a3be4
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-hclog/stacktrace.go
@@ -0,0 +1,108 @@
+// Copyright (c) 2016 Uber Technologies, Inc.
+//
+// Permission is hereby granted, free of charge, to any person obtaining a copy
+// of this software and associated documentation files (the "Software"), to deal
+// in the Software without restriction, including without limitation the rights
+// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+// copies of the Software, and to permit persons to whom the Software is
+// furnished to do so, subject to the following conditions:
+//
+// The above copyright notice and this permission notice shall be included in
+// all copies or substantial portions of the Software.
+//
+// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+// THE SOFTWARE.
+
+package hclog
+
+import (
+	"bytes"
+	"runtime"
+	"strconv"
+	"strings"
+	"sync"
+)
+
+var (
+	_stacktraceIgnorePrefixes = []string{
+		"runtime.goexit",
+		"runtime.main",
+	}
+	_stacktracePool = sync.Pool{
+		New: func() interface{} {
+			return newProgramCounters(64)
+		},
+	}
+)
+
+// A stacktrace gathered by a previous call to log.Stacktrace. If passed
+// to a logging function, the stacktrace will be appended.
+type CapturedStacktrace string
+
+// Gather a stacktrace of the current goroutine and return it to be passed
+// to a logging function.
+func Stacktrace() CapturedStacktrace {
+	return CapturedStacktrace(takeStacktrace())
+}
+
+func takeStacktrace() string {
+	programCounters := _stacktracePool.Get().(*programCounters)
+	defer _stacktracePool.Put(programCounters)
+
+	var buffer bytes.Buffer
+
+	for {
+		// Skip the call to runtime.Counters and takeStacktrace so that the
+		// program counters start at the caller of takeStacktrace.
+		n := runtime.Callers(2, programCounters.pcs)
+		if n < cap(programCounters.pcs) {
+			programCounters.pcs = programCounters.pcs[:n]
+			break
+		}
+		// Don't put the too-short counter slice back into the pool; this lets
+		// the pool adjust if we consistently take deep stacktraces.
+		programCounters = newProgramCounters(len(programCounters.pcs) * 2)
+	}
+
+	i := 0
+	frames := runtime.CallersFrames(programCounters.pcs)
+	for frame, more := frames.Next(); more; frame, more = frames.Next() {
+		if shouldIgnoreStacktraceFunction(frame.Function) {
+			continue
+		}
+		if i != 0 {
+			buffer.WriteByte('\n')
+		}
+		i++
+		buffer.WriteString(frame.Function)
+		buffer.WriteByte('\n')
+		buffer.WriteByte('\t')
+		buffer.WriteString(frame.File)
+		buffer.WriteByte(':')
+		buffer.WriteString(strconv.Itoa(int(frame.Line)))
+	}
+
+	return buffer.String()
+}
+
+func shouldIgnoreStacktraceFunction(function string) bool {
+	for _, prefix := range _stacktraceIgnorePrefixes {
+		if strings.HasPrefix(function, prefix) {
+			return true
+		}
+	}
+	return false
+}
+
+type programCounters struct {
+	pcs []uintptr
+}
+
+func newProgramCounters(size int) *programCounters {
+	return &programCounters{make([]uintptr, size)}
+}
diff --git a/vendor/github.com/hashicorp/go-hclog/stdlog.go b/vendor/github.com/hashicorp/go-hclog/stdlog.go
new file mode 100644
index 000000000..2bb927fc9
--- /dev/null
+++ b/vendor/github.com/hashicorp/go-hclog/stdlog.go
@@ -0,0 +1,62 @@
+package hclog
+
+import (
+	"bytes"
+	"strings"
+)
+
+// Provides a io.Writer to shim the data out of *log.Logger
+// and back into our Logger. This is basically the only way to
+// build upon *log.Logger.
+type stdlogAdapter struct {
+	hl          Logger
+	inferLevels bool
+}
+
+// Take the data, infer the levels if configured, and send it through
+// a regular Logger
+func (s *stdlogAdapter) Write(data []byte) (int, error) {
+	str := string(bytes.TrimRight(data, " \t\n"))
+
+	if s.inferLevels {
+		level, str := s.pickLevel(str)
+		switch level {
+		case Trace:
+			s.hl.Trace(str)
+		case Debug:
+			s.hl.Debug(str)
+		case Info:
+			s.hl.Info(str)
+		case Warn:
+			s.hl.Warn(str)
+		case Error:
+			s.hl.Error(str)
+		default:
+			s.hl.Info(str)
+		}
+	} else {
+		s.hl.Info(str)
+	}
+
+	return len(data), nil
+}
+
+// Detect, based on conventions, what log level this is
+func (s *stdlogAdapter) pickLevel(str string) (Level, string) {
+	switch {
+	case strings.HasPrefix(str, "[DEBUG]"):
+		return Debug, strings.TrimSpace(str[7:])
+	case strings.HasPrefix(str, "[TRACE]"):
+		return Trace, strings.TrimSpace(str[7:])
+	case strings.HasPrefix(str, "[INFO]"):
+		return Info, strings.TrimSpace(str[6:])
+	case strings.HasPrefix(str, "[WARN]"):
+		return Warn, strings.TrimSpace(str[7:])
+	case strings.HasPrefix(str, "[ERROR]"):
+		return Error, strings.TrimSpace(str[7:])
+	case strings.HasPrefix(str, "[ERR]"):
+		return Error, strings.TrimSpace(str[5:])
+	default:
+		return Info, str
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl2/LICENSE b/vendor/github.com/hashicorp/hcl2/LICENSE
new file mode 100644
index 000000000..82b4de97c
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/LICENSE
@@ -0,0 +1,353 @@
+Mozilla Public License, version 2.0
+
+1. Definitions
+
+1.1. “Contributor”
+
+     means each individual or legal entity that creates, contributes to the
+     creation of, or owns Covered Software.
+
+1.2. “Contributor Version”
+
+     means the combination of the Contributions of others (if any) used by a
+     Contributor and that particular Contributor’s Contribution.
+
+1.3. “Contribution”
+
+     means Covered Software of a particular Contributor.
+
+1.4. “Covered Software”
+
+     means Source Code Form to which the initial Contributor has attached the
+     notice in Exhibit A, the Executable Form of such Source Code Form, and
+     Modifications of such Source Code Form, in each case including portions
+     thereof.
+
+1.5. “Incompatible With Secondary Licenses”
+     means
+
+     a. that the initial Contributor has attached the notice described in
+        Exhibit B to the Covered Software; or
+
+     b. that the Covered Software was made available under the terms of version
+        1.1 or earlier of the License, but not also under the terms of a
+        Secondary License.
+
+1.6. “Executable Form”
+
+     means any form of the work other than Source Code Form.
+
+1.7. “Larger Work”
+
+     means a work that combines Covered Software with other material, in a separate
+     file or files, that is not Covered Software.
+
+1.8. “License”
+
+     means this document.
+
+1.9. “Licensable”
+
+     means having the right to grant, to the maximum extent possible, whether at the
+     time of the initial grant or subsequently, any and all of the rights conveyed by
+     this License.
+
+1.10. “Modifications”
+
+     means any of the following:
+
+     a. any file in Source Code Form that results from an addition to, deletion
+        from, or modification of the contents of Covered Software; or
+
+     b. any new file in Source Code Form that contains any Covered Software.
+
+1.11. “Patent Claims” of a Contributor
+
+      means any patent claim(s), including without limitation, method, process,
+      and apparatus claims, in any patent Licensable by such Contributor that
+      would be infringed, but for the grant of the License, by the making,
+      using, selling, offering for sale, having made, import, or transfer of
+      either its Contributions or its Contributor Version.
+
+1.12. “Secondary License”
+
+      means either the GNU General Public License, Version 2.0, the GNU Lesser
+      General Public License, Version 2.1, the GNU Affero General Public
+      License, Version 3.0, or any later versions of those licenses.
+
+1.13. “Source Code Form”
+
+      means the form of the work preferred for making modifications.
+
+1.14. “You” (or “Your”)
+
+      means an individual or a legal entity exercising rights under this
+      License. For legal entities, “You” includes any entity that controls, is
+      controlled by, or is under common control with You. For purposes of this
+      definition, “control” means (a) the power, direct or indirect, to cause
+      the direction or management of such entity, whether by contract or
+      otherwise, or (b) ownership of more than fifty percent (50%) of the
+      outstanding shares or beneficial ownership of such entity.
+
+
+2. License Grants and Conditions
+
+2.1. Grants
+
+     Each Contributor hereby grants You a world-wide, royalty-free,
+     non-exclusive license:
+
+     a. under intellectual property rights (other than patent or trademark)
+        Licensable by such Contributor to use, reproduce, make available,
+        modify, display, perform, distribute, and otherwise exploit its
+        Contributions, either on an unmodified basis, with Modifications, or as
+        part of a Larger Work; and
+
+     b. under Patent Claims of such Contributor to make, use, sell, offer for
+        sale, have made, import, and otherwise transfer either its Contributions
+        or its Contributor Version.
+
+2.2. Effective Date
+
+     The licenses granted in Section 2.1 with respect to any Contribution become
+     effective for each Contribution on the date the Contributor first distributes
+     such Contribution.
+
+2.3. Limitations on Grant Scope
+
+     The licenses granted in this Section 2 are the only rights granted under this
+     License. No additional rights or licenses will be implied from the distribution
+     or licensing of Covered Software under this License. Notwithstanding Section
+     2.1(b) above, no patent license is granted by a Contributor:
+
+     a. for any code that a Contributor has removed from Covered Software; or
+
+     b. for infringements caused by: (i) Your and any other third party’s
+        modifications of Covered Software, or (ii) the combination of its
+        Contributions with other software (except as part of its Contributor
+        Version); or
+
+     c. under Patent Claims infringed by Covered Software in the absence of its
+        Contributions.
+
+     This License does not grant any rights in the trademarks, service marks, or
+     logos of any Contributor (except as may be necessary to comply with the
+     notice requirements in Section 3.4).
+
+2.4. Subsequent Licenses
+
+     No Contributor makes additional grants as a result of Your choice to
+     distribute the Covered Software under a subsequent version of this License
+     (see Section 10.2) or under the terms of a Secondary License (if permitted
+     under the terms of Section 3.3).
+
+2.5. Representation
+
+     Each Contributor represents that the Contributor believes its Contributions
+     are its original creation(s) or it has sufficient rights to grant the
+     rights to its Contributions conveyed by this License.
+
+2.6. Fair Use
+
+     This License is not intended to limit any rights You have under applicable
+     copyright doctrines of fair use, fair dealing, or other equivalents.
+
+2.7. Conditions
+
+     Sections 3.1, 3.2, 3.3, and 3.4 are conditions of the licenses granted in
+     Section 2.1.
+
+
+3. Responsibilities
+
+3.1. Distribution of Source Form
+
+     All distribution of Covered Software in Source Code Form, including any
+     Modifications that You create or to which You contribute, must be under the
+     terms of this License. You must inform recipients that the Source Code Form
+     of the Covered Software is governed by the terms of this License, and how
+     they can obtain a copy of this License. You may not attempt to alter or
+     restrict the recipients’ rights in the Source Code Form.
+
+3.2. Distribution of Executable Form
+
+     If You distribute Covered Software in Executable Form then:
+
+     a. such Covered Software must also be made available in Source Code Form,
+        as described in Section 3.1, and You must inform recipients of the
+        Executable Form how they can obtain a copy of such Source Code Form by
+        reasonable means in a timely manner, at a charge no more than the cost
+        of distribution to the recipient; and
+
+     b. You may distribute such Executable Form under the terms of this License,
+        or sublicense it under different terms, provided that the license for
+        the Executable Form does not attempt to limit or alter the recipients’
+        rights in the Source Code Form under this License.
+
+3.3. Distribution of a Larger Work
+
+     You may create and distribute a Larger Work under terms of Your choice,
+     provided that You also comply with the requirements of this License for the
+     Covered Software. If the Larger Work is a combination of Covered Software
+     with a work governed by one or more Secondary Licenses, and the Covered
+     Software is not Incompatible With Secondary Licenses, this License permits
+     You to additionally distribute such Covered Software under the terms of
+     such Secondary License(s), so that the recipient of the Larger Work may, at
+     their option, further distribute the Covered Software under the terms of
+     either this License or such Secondary License(s).
+
+3.4. Notices
+
+     You may not remove or alter the substance of any license notices (including
+     copyright notices, patent notices, disclaimers of warranty, or limitations
+     of liability) contained within the Source Code Form of the Covered
+     Software, except that You may alter any license notices to the extent
+     required to remedy known factual inaccuracies.
+
+3.5. Application of Additional Terms
+
+     You may choose to offer, and to charge a fee for, warranty, support,
+     indemnity or liability obligations to one or more recipients of Covered
+     Software. However, You may do so only on Your own behalf, and not on behalf
+     of any Contributor. You must make it absolutely clear that any such
+     warranty, support, indemnity, or liability obligation is offered by You
+     alone, and You hereby agree to indemnify every Contributor for any
+     liability incurred by such Contributor as a result of warranty, support,
+     indemnity or liability terms You offer. You may include additional
+     disclaimers of warranty and limitations of liability specific to any
+     jurisdiction.
+
+4. Inability to Comply Due to Statute or Regulation
+
+   If it is impossible for You to comply with any of the terms of this License
+   with respect to some or all of the Covered Software due to statute, judicial
+   order, or regulation then You must: (a) comply with the terms of this License
+   to the maximum extent possible; and (b) describe the limitations and the code
+   they affect. Such description must be placed in a text file included with all
+   distributions of the Covered Software under this License. Except to the
+   extent prohibited by statute or regulation, such description must be
+   sufficiently detailed for a recipient of ordinary skill to be able to
+   understand it.
+
+5. Termination
+
+5.1. The rights granted under this License will terminate automatically if You
+     fail to comply with any of its terms. However, if You become compliant,
+     then the rights granted under this License from a particular Contributor
+     are reinstated (a) provisionally, unless and until such Contributor
+     explicitly and finally terminates Your grants, and (b) on an ongoing basis,
+     if such Contributor fails to notify You of the non-compliance by some
+     reasonable means prior to 60 days after You have come back into compliance.
+     Moreover, Your grants from a particular Contributor are reinstated on an
+     ongoing basis if such Contributor notifies You of the non-compliance by
+     some reasonable means, this is the first time You have received notice of
+     non-compliance with this License from such Contributor, and You become
+     compliant prior to 30 days after Your receipt of the notice.
+
+5.2. If You initiate litigation against any entity by asserting a patent
+     infringement claim (excluding declaratory judgment actions, counter-claims,
+     and cross-claims) alleging that a Contributor Version directly or
+     indirectly infringes any patent, then the rights granted to You by any and
+     all Contributors for the Covered Software under Section 2.1 of this License
+     shall terminate.
+
+5.3. In the event of termination under Sections 5.1 or 5.2 above, all end user
+     license agreements (excluding distributors and resellers) which have been
+     validly granted by You or Your distributors under this License prior to
+     termination shall survive termination.
+
+6. Disclaimer of Warranty
+
+   Covered Software is provided under this License on an “as is” basis, without
+   warranty of any kind, either expressed, implied, or statutory, including,
+   without limitation, warranties that the Covered Software is free of defects,
+   merchantable, fit for a particular purpose or non-infringing. The entire
+   risk as to the quality and performance of the Covered Software is with You.
+   Should any Covered Software prove defective in any respect, You (not any
+   Contributor) assume the cost of any necessary servicing, repair, or
+   correction. This disclaimer of warranty constitutes an essential part of this
+   License. No use of  any Covered Software is authorized under this License
+   except under this disclaimer.
+
+7. Limitation of Liability
+
+   Under no circumstances and under no legal theory, whether tort (including
+   negligence), contract, or otherwise, shall any Contributor, or anyone who
+   distributes Covered Software as permitted above, be liable to You for any
+   direct, indirect, special, incidental, or consequential damages of any
+   character including, without limitation, damages for lost profits, loss of
+   goodwill, work stoppage, computer failure or malfunction, or any and all
+   other commercial damages or losses, even if such party shall have been
+   informed of the possibility of such damages. This limitation of liability
+   shall not apply to liability for death or personal injury resulting from such
+   party’s negligence to the extent applicable law prohibits such limitation.
+   Some jurisdictions do not allow the exclusion or limitation of incidental or
+   consequential damages, so this exclusion and limitation may not apply to You.
+
+8. Litigation
+
+   Any litigation relating to this License may be brought only in the courts of
+   a jurisdiction where the defendant maintains its principal place of business
+   and such litigation shall be governed by laws of that jurisdiction, without
+   reference to its conflict-of-law provisions. Nothing in this Section shall
+   prevent a party’s ability to bring cross-claims or counter-claims.
+
+9. Miscellaneous
+
+   This License represents the complete agreement concerning the subject matter
+   hereof. If any provision of this License is held to be unenforceable, such
+   provision shall be reformed only to the extent necessary to make it
+   enforceable. Any law or regulation which provides that the language of a
+   contract shall be construed against the drafter shall not be used to construe
+   this License against a Contributor.
+
+
+10. Versions of the License
+
+10.1. New Versions
+
+      Mozilla Foundation is the license steward. Except as provided in Section
+      10.3, no one other than the license steward has the right to modify or
+      publish new versions of this License. Each version will be given a
+      distinguishing version number.
+
+10.2. Effect of New Versions
+
+      You may distribute the Covered Software under the terms of the version of
+      the License under which You originally received the Covered Software, or
+      under the terms of any subsequent version published by the license
+      steward.
+
+10.3. Modified Versions
+
+      If you create software not governed by this License, and you want to
+      create a new license for such software, you may create and use a modified
+      version of this License if you rename the license and remove any
+      references to the name of the license steward (except to note that such
+      modified license differs from this License).
+
+10.4. Distributing Source Code Form that is Incompatible With Secondary Licenses
+      If You choose to distribute Source Code Form that is Incompatible With
+      Secondary Licenses under the terms of this version of the License, the
+      notice described in Exhibit B of this License must be attached.
+
+Exhibit A - Source Code Form License Notice
+
+      This Source Code Form is subject to the
+      terms of the Mozilla Public License, v.
+      2.0. If a copy of the MPL was not
+      distributed with this file, You can
+      obtain one at
+      http://mozilla.org/MPL/2.0/.
+
+If it is not possible or desirable to put the notice in a particular file, then
+You may include the notice in a location (such as a LICENSE file in a relevant
+directory) where a recipient would be likely to look for such a notice.
+
+You may add additional accurate notices of copyright ownership.
+
+Exhibit B - “Incompatible With Secondary Licenses” Notice
+
+      This Source Code Form is “Incompatible
+      With Secondary Licenses”, as defined by
+      the Mozilla Public License, v. 2.0.
diff --git a/vendor/github.com/hashicorp/hcl2/gohcl/decode.go b/vendor/github.com/hashicorp/hcl2/gohcl/decode.go
new file mode 100644
index 000000000..3a149a8c2
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/gohcl/decode.go
@@ -0,0 +1,304 @@
+package gohcl
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+
+	"github.com/hashicorp/hcl2/hcl"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/gocty"
+)
+
+// DecodeBody extracts the configuration within the given body into the given
+// value. This value must be a non-nil pointer to either a struct or
+// a map, where in the former case the configuration will be decoded using
+// struct tags and in the latter case only attributes are allowed and their
+// values are decoded into the map.
+//
+// The given EvalContext is used to resolve any variables or functions in
+// expressions encountered while decoding. This may be nil to require only
+// constant values, for simple applications that do not support variables or
+// functions.
+//
+// The returned diagnostics should be inspected with its HasErrors method to
+// determine if the populated value is valid and complete. If error diagnostics
+// are returned then the given value may have been partially-populated but
+// may still be accessed by a careful caller for static analysis and editor
+// integration use-cases.
+func DecodeBody(body hcl.Body, ctx *hcl.EvalContext, val interface{}) hcl.Diagnostics {
+	rv := reflect.ValueOf(val)
+	if rv.Kind() != reflect.Ptr {
+		panic(fmt.Sprintf("target value must be a pointer, not %s", rv.Type().String()))
+	}
+
+	return decodeBodyToValue(body, ctx, rv.Elem())
+}
+
+func decodeBodyToValue(body hcl.Body, ctx *hcl.EvalContext, val reflect.Value) hcl.Diagnostics {
+	et := val.Type()
+	switch et.Kind() {
+	case reflect.Struct:
+		return decodeBodyToStruct(body, ctx, val)
+	case reflect.Map:
+		return decodeBodyToMap(body, ctx, val)
+	default:
+		panic(fmt.Sprintf("target value must be pointer to struct or map, not %s", et.String()))
+	}
+}
+
+func decodeBodyToStruct(body hcl.Body, ctx *hcl.EvalContext, val reflect.Value) hcl.Diagnostics {
+	schema, partial := ImpliedBodySchema(val.Interface())
+
+	var content *hcl.BodyContent
+	var leftovers hcl.Body
+	var diags hcl.Diagnostics
+	if partial {
+		content, leftovers, diags = body.PartialContent(schema)
+	} else {
+		content, diags = body.Content(schema)
+	}
+	if content == nil {
+		return diags
+	}
+
+	tags := getFieldTags(val.Type())
+
+	if tags.Remain != nil {
+		fieldIdx := *tags.Remain
+		field := val.Type().Field(fieldIdx)
+		fieldV := val.Field(fieldIdx)
+		switch {
+		case bodyType.AssignableTo(field.Type):
+			fieldV.Set(reflect.ValueOf(leftovers))
+		case attrsType.AssignableTo(field.Type):
+			attrs, attrsDiags := leftovers.JustAttributes()
+			if len(attrsDiags) > 0 {
+				diags = append(diags, attrsDiags...)
+			}
+			fieldV.Set(reflect.ValueOf(attrs))
+		default:
+			diags = append(diags, decodeBodyToValue(leftovers, ctx, fieldV)...)
+		}
+	}
+
+	for name, fieldIdx := range tags.Attributes {
+		attr := content.Attributes[name]
+		field := val.Type().Field(fieldIdx)
+		fieldV := val.Field(fieldIdx)
+
+		if attr == nil {
+			if !exprType.AssignableTo(field.Type) {
+				continue
+			}
+
+			// As a special case, if the target is of type hcl.Expression then
+			// we'll assign an actual expression that evalues to a cty null,
+			// so the caller can deal with it within the cty realm rather
+			// than within the Go realm.
+			synthExpr := hcl.StaticExpr(cty.NullVal(cty.DynamicPseudoType), body.MissingItemRange())
+			fieldV.Set(reflect.ValueOf(synthExpr))
+			continue
+		}
+
+		switch {
+		case attrType.AssignableTo(field.Type):
+			fieldV.Set(reflect.ValueOf(attr))
+		case exprType.AssignableTo(field.Type):
+			fieldV.Set(reflect.ValueOf(attr.Expr))
+		default:
+			diags = append(diags, DecodeExpression(
+				attr.Expr, ctx, fieldV.Addr().Interface(),
+			)...)
+		}
+	}
+
+	blocksByType := content.Blocks.ByType()
+
+	for typeName, fieldIdx := range tags.Blocks {
+		blocks := blocksByType[typeName]
+		field := val.Type().Field(fieldIdx)
+
+		ty := field.Type
+		isSlice := false
+		isPtr := false
+		if ty.Kind() == reflect.Slice {
+			isSlice = true
+			ty = ty.Elem()
+		}
+		if ty.Kind() == reflect.Ptr {
+			isPtr = true
+			ty = ty.Elem()
+		}
+
+		if len(blocks) > 1 && !isSlice {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Duplicate %s block", typeName),
+				Detail: fmt.Sprintf(
+					"Only one %s block is allowed. Another was defined at %s.",
+					typeName, blocks[0].DefRange.String(),
+				),
+				Subject: &blocks[1].DefRange,
+			})
+			continue
+		}
+
+		if len(blocks) == 0 {
+			if isSlice || isPtr {
+				val.Field(fieldIdx).Set(reflect.Zero(field.Type))
+			} else {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  fmt.Sprintf("Missing %s block", typeName),
+					Detail:   fmt.Sprintf("A %s block is required.", typeName),
+					Subject:  body.MissingItemRange().Ptr(),
+				})
+			}
+			continue
+		}
+
+		switch {
+
+		case isSlice:
+			elemType := ty
+			if isPtr {
+				elemType = reflect.PtrTo(ty)
+			}
+			sli := reflect.MakeSlice(reflect.SliceOf(elemType), len(blocks), len(blocks))
+
+			for i, block := range blocks {
+				if isPtr {
+					v := reflect.New(ty)
+					diags = append(diags, decodeBlockToValue(block, ctx, v.Elem())...)
+					sli.Index(i).Set(v)
+				} else {
+					diags = append(diags, decodeBlockToValue(block, ctx, sli.Index(i))...)
+				}
+			}
+
+			val.Field(fieldIdx).Set(sli)
+
+		default:
+			block := blocks[0]
+			if isPtr {
+				v := reflect.New(ty)
+				diags = append(diags, decodeBlockToValue(block, ctx, v.Elem())...)
+				val.Field(fieldIdx).Set(v)
+			} else {
+				diags = append(diags, decodeBlockToValue(block, ctx, val.Field(fieldIdx))...)
+			}
+
+		}
+
+	}
+
+	return diags
+}
+
+func decodeBodyToMap(body hcl.Body, ctx *hcl.EvalContext, v reflect.Value) hcl.Diagnostics {
+	attrs, diags := body.JustAttributes()
+	if attrs == nil {
+		return diags
+	}
+
+	mv := reflect.MakeMap(v.Type())
+
+	for k, attr := range attrs {
+		switch {
+		case attrType.AssignableTo(v.Type().Elem()):
+			mv.SetMapIndex(reflect.ValueOf(k), reflect.ValueOf(attr))
+		case exprType.AssignableTo(v.Type().Elem()):
+			mv.SetMapIndex(reflect.ValueOf(k), reflect.ValueOf(attr.Expr))
+		default:
+			ev := reflect.New(v.Type().Elem())
+			diags = append(diags, DecodeExpression(attr.Expr, ctx, ev.Interface())...)
+			mv.SetMapIndex(reflect.ValueOf(k), ev.Elem())
+		}
+	}
+
+	v.Set(mv)
+
+	return diags
+}
+
+func decodeBlockToValue(block *hcl.Block, ctx *hcl.EvalContext, v reflect.Value) hcl.Diagnostics {
+	var diags hcl.Diagnostics
+
+	ty := v.Type()
+
+	switch {
+	case blockType.AssignableTo(ty):
+		v.Elem().Set(reflect.ValueOf(block))
+	case bodyType.AssignableTo(ty):
+		v.Elem().Set(reflect.ValueOf(block.Body))
+	case attrsType.AssignableTo(ty):
+		attrs, attrsDiags := block.Body.JustAttributes()
+		if len(attrsDiags) > 0 {
+			diags = append(diags, attrsDiags...)
+		}
+		v.Elem().Set(reflect.ValueOf(attrs))
+	default:
+		diags = append(diags, decodeBodyToValue(block.Body, ctx, v)...)
+
+		if len(block.Labels) > 0 {
+			blockTags := getFieldTags(ty)
+			for li, lv := range block.Labels {
+				lfieldIdx := blockTags.Labels[li].FieldIndex
+				v.Field(lfieldIdx).Set(reflect.ValueOf(lv))
+			}
+		}
+
+	}
+
+	return diags
+}
+
+// DecodeExpression extracts the value of the given expression into the given
+// value. This value must be something that gocty is able to decode into,
+// since the final decoding is delegated to that package.
+//
+// The given EvalContext is used to resolve any variables or functions in
+// expressions encountered while decoding. This may be nil to require only
+// constant values, for simple applications that do not support variables or
+// functions.
+//
+// The returned diagnostics should be inspected with its HasErrors method to
+// determine if the populated value is valid and complete. If error diagnostics
+// are returned then the given value may have been partially-populated but
+// may still be accessed by a careful caller for static analysis and editor
+// integration use-cases.
+func DecodeExpression(expr hcl.Expression, ctx *hcl.EvalContext, val interface{}) hcl.Diagnostics {
+	srcVal, diags := expr.Value(ctx)
+
+	convTy, err := gocty.ImpliedType(val)
+	if err != nil {
+		panic(fmt.Sprintf("unsuitable DecodeExpression target: %s", err))
+	}
+
+	srcVal, err = convert.Convert(srcVal, convTy)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Unsuitable value type",
+			Detail:   fmt.Sprintf("Unsuitable value: %s", err.Error()),
+			Subject:  expr.StartRange().Ptr(),
+			Context:  expr.Range().Ptr(),
+		})
+		return diags
+	}
+
+	err = gocty.FromCtyValue(srcVal, val)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Unsuitable value type",
+			Detail:   fmt.Sprintf("Unsuitable value: %s", err.Error()),
+			Subject:  expr.StartRange().Ptr(),
+			Context:  expr.Range().Ptr(),
+		})
+	}
+
+	return diags
+}
diff --git a/vendor/github.com/hashicorp/hcl2/gohcl/doc.go b/vendor/github.com/hashicorp/hcl2/gohcl/doc.go
new file mode 100644
index 000000000..8500214bf
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/gohcl/doc.go
@@ -0,0 +1,49 @@
+// Package gohcl allows decoding HCL configurations into Go data structures.
+//
+// It provides a convenient and concise way of describing the schema for
+// configuration and then accessing the resulting data via native Go
+// types.
+//
+// A struct field tag scheme is used, similar to other decoding and
+// unmarshalling libraries. The tags are formatted as in the following example:
+//
+//    ThingType string `hcl:"thing_type,attr"`
+//
+// Within each tag there are two comma-separated tokens. The first is the
+// name of the corresponding construct in configuration, while the second
+// is a keyword giving the kind of construct expected. The following
+// kind keywords are supported:
+//
+//    attr (the default) indicates that the value is to be populated from an attribute
+//    block indicates that the value is to populated from a block
+//    label indicates that the value is to populated from a block label
+//    remain indicates that the value is to be populated from the remaining body after populating other fields
+//
+// "attr" fields may either be of type *hcl.Expression, in which case the raw
+// expression is assigned, or of any type accepted by gocty, in which case
+// gocty will be used to assign the value to a native Go type.
+//
+// "block" fields may be of type *hcl.Block or hcl.Body, in which case the
+// corresponding raw value is assigned, or may be a struct that recursively
+// uses the same tags. Block fields may also be slices of any of these types,
+// in which case multiple blocks of the corresponding type are decoded into
+// the slice.
+//
+// "label" fields are considered only in a struct used as the type of a field
+// marked as "block", and are used sequentially to capture the labels of
+// the blocks being decoded. In this case, the name token is used only as
+// an identifier for the label in diagnostic messages.
+//
+// "remain" can be placed on a single field that may be either of type
+// hcl.Body or hcl.Attributes, in which case any remaining body content is
+// placed into this field for delayed processing. If no "remain" field is
+// present then any attributes or blocks not matched by another valid tag
+// will cause an error diagnostic.
+//
+// Broadly-speaking this package deals with two types of error. The first is
+// errors in the configuration itself, which are returned as diagnostics
+// written with the configuration author as the target audience. The second
+// is bugs in the calling program, such as invalid struct tags, which are
+// surfaced via panics since there can be no useful runtime handling of such
+// errors and they should certainly not be returned to the user as diagnostics.
+package gohcl
diff --git a/vendor/github.com/hashicorp/hcl2/gohcl/schema.go b/vendor/github.com/hashicorp/hcl2/gohcl/schema.go
new file mode 100644
index 000000000..a8955dcdc
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/gohcl/schema.go
@@ -0,0 +1,167 @@
+package gohcl
+
+import (
+	"fmt"
+	"reflect"
+	"sort"
+	"strings"
+
+	"github.com/hashicorp/hcl2/hcl"
+)
+
+// ImpliedBodySchema produces a hcl.BodySchema derived from the type of the
+// given value, which must be a struct value or a pointer to one. If an
+// inappropriate value is passed, this function will panic.
+//
+// The second return argument indicates whether the given struct includes
+// a "remain" field, and thus the returned schema is non-exhaustive.
+//
+// This uses the tags on the fields of the struct to discover how each
+// field's value should be expressed within configuration. If an invalid
+// mapping is attempted, this function will panic.
+func ImpliedBodySchema(val interface{}) (schema *hcl.BodySchema, partial bool) {
+	ty := reflect.TypeOf(val)
+
+	if ty.Kind() == reflect.Ptr {
+		ty = ty.Elem()
+	}
+
+	if ty.Kind() != reflect.Struct {
+		panic(fmt.Sprintf("given value must be struct, not %T", val))
+	}
+
+	var attrSchemas []hcl.AttributeSchema
+	var blockSchemas []hcl.BlockHeaderSchema
+
+	tags := getFieldTags(ty)
+
+	attrNames := make([]string, 0, len(tags.Attributes))
+	for n := range tags.Attributes {
+		attrNames = append(attrNames, n)
+	}
+	sort.Strings(attrNames)
+	for _, n := range attrNames {
+		idx := tags.Attributes[n]
+		field := ty.Field(idx)
+		var required bool
+
+		switch {
+		case field.Type.AssignableTo(exprType):
+			// If we're decoding to hcl.Expression then absense can be
+			// indicated via a null value, so we don't specify that
+			// the field is required during decoding.
+			required = false
+		case field.Type.Kind() != reflect.Ptr:
+			required = true
+		default:
+			required = false
+		}
+
+		attrSchemas = append(attrSchemas, hcl.AttributeSchema{
+			Name:     n,
+			Required: required,
+		})
+	}
+
+	blockNames := make([]string, 0, len(tags.Blocks))
+	for n := range tags.Blocks {
+		blockNames = append(blockNames, n)
+	}
+	sort.Strings(blockNames)
+	for _, n := range blockNames {
+		idx := tags.Blocks[n]
+		field := ty.Field(idx)
+		fty := field.Type
+		if fty.Kind() == reflect.Slice {
+			fty = fty.Elem()
+		}
+		if fty.Kind() == reflect.Ptr {
+			fty = fty.Elem()
+		}
+		if fty.Kind() != reflect.Struct {
+			panic(fmt.Sprintf(
+				"hcl 'block' tag kind cannot be applied to %s field %s: struct required", field.Type.String(), field.Name,
+			))
+		}
+		ftags := getFieldTags(fty)
+		var labelNames []string
+		if len(ftags.Labels) > 0 {
+			labelNames = make([]string, len(ftags.Labels))
+			for i, l := range ftags.Labels {
+				labelNames[i] = l.Name
+			}
+		}
+
+		blockSchemas = append(blockSchemas, hcl.BlockHeaderSchema{
+			Type:       n,
+			LabelNames: labelNames,
+		})
+	}
+
+	partial = tags.Remain != nil
+	schema = &hcl.BodySchema{
+		Attributes: attrSchemas,
+		Blocks:     blockSchemas,
+	}
+	return schema, partial
+}
+
+type fieldTags struct {
+	Attributes map[string]int
+	Blocks     map[string]int
+	Labels     []labelField
+	Remain     *int
+}
+
+type labelField struct {
+	FieldIndex int
+	Name       string
+}
+
+func getFieldTags(ty reflect.Type) *fieldTags {
+	ret := &fieldTags{
+		Attributes: map[string]int{},
+		Blocks:     map[string]int{},
+	}
+
+	ct := ty.NumField()
+	for i := 0; i < ct; i++ {
+		field := ty.Field(i)
+		tag := field.Tag.Get("hcl")
+		if tag == "" {
+			continue
+		}
+
+		comma := strings.Index(tag, ",")
+		var name, kind string
+		if comma != -1 {
+			name = tag[:comma]
+			kind = tag[comma+1:]
+		} else {
+			name = tag
+			kind = "attr"
+		}
+
+		switch kind {
+		case "attr":
+			ret.Attributes[name] = i
+		case "block":
+			ret.Blocks[name] = i
+		case "label":
+			ret.Labels = append(ret.Labels, labelField{
+				FieldIndex: i,
+				Name:       name,
+			})
+		case "remain":
+			if ret.Remain != nil {
+				panic("only one 'remain' tag is permitted")
+			}
+			idx := i // copy, because this loop will continue assigning to i
+			ret.Remain = &idx
+		default:
+			panic(fmt.Sprintf("invalid hcl field tag kind %q on %s %q", kind, field.Type.String(), field.Name))
+		}
+	}
+
+	return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl2/gohcl/types.go b/vendor/github.com/hashicorp/hcl2/gohcl/types.go
new file mode 100644
index 000000000..a94f275ad
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/gohcl/types.go
@@ -0,0 +1,16 @@
+package gohcl
+
+import (
+	"reflect"
+
+	"github.com/hashicorp/hcl2/hcl"
+)
+
+var victimExpr hcl.Expression
+var victimBody hcl.Body
+
+var exprType = reflect.TypeOf(&victimExpr).Elem()
+var bodyType = reflect.TypeOf(&victimBody).Elem()
+var blockType = reflect.TypeOf((*hcl.Block)(nil))
+var attrType = reflect.TypeOf((*hcl.Attribute)(nil))
+var attrsType = reflect.TypeOf(hcl.Attributes(nil))
diff --git a/vendor/github.com/hashicorp/hcl2/hcl/diagnostic.go b/vendor/github.com/hashicorp/hcl2/hcl/diagnostic.go
new file mode 100644
index 000000000..6ecf7447f
--- /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 000000000..9776f04de
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/diagnostic_text.go
@@ -0,0 +1,163 @@
+package hcl
+
+import (
+	"bufio"
+	"bytes"
+	"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, resetCode string
+	if w.color {
+		switch diag.Severity {
+		case DiagError:
+			colorCode = "\x1b[31m"
+		case DiagWarning:
+			colorCode = "\x1b[33m"
+		}
+		resetCode = "\x1b[0m"
+	}
+
+	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 {
+
+		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 {
+			src := file.Bytes
+			r := bytes.NewReader(src)
+			sc := bufio.NewScanner(r)
+			sc.Split(bufio.ScanLines)
+
+			var startLine, endLine int
+			if diag.Context != nil {
+				startLine = diag.Context.Start.Line
+				endLine = diag.Context.End.Line
+			} else {
+				startLine = diag.Subject.Start.Line
+				endLine = diag.Subject.End.Line
+			}
+
+			var contextLine string
+			if diag.Subject != nil {
+				contextLine = contextString(file, diag.Subject.Start.Byte)
+				if contextLine != "" {
+					contextLine = ", in " + contextLine
+				}
+			}
+
+			li := 1
+			var ls string
+			for sc.Scan() {
+				ls = sc.Text()
+
+				if li == startLine {
+					break
+				}
+				li++
+			}
+
+			fmt.Fprintf(w.wr, "  on %s line %d%s:\n", diag.Subject.Filename, diag.Subject.Start.Line, contextLine)
+
+			// TODO: Generate markers for the specific characters that are in the Context and Subject ranges.
+			// For now, we just print out the lines.
+
+			fmt.Fprintf(w.wr, "%4d: %s\n", li, ls)
+
+			if endLine > li {
+				for sc.Scan() {
+					ls = sc.Text()
+					li++
+
+					fmt.Fprintf(w.wr, "%4d: %s\n", li, ls)
+
+					if li == endLine {
+						break
+					}
+				}
+			}
+
+			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 000000000..c12833440
--- /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 000000000..01318c96f
--- /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 000000000..915910ad8
--- /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/hclsyntax/didyoumean.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/didyoumean.go
new file mode 100644
index 000000000..ccc1c0ae2
--- /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 000000000..8db11573f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/doc.go
@@ -0,0 +1,7 @@
+// Package hclsyntax contains the parser, AST, etc for zcl'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 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 000000000..e90ac2be6
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression.go
@@ -0,0 +1,1121 @@
+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 zcl 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
+}
+
+// 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
+}
+
+// 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
+}
+
+// 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)
+}
+
+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
+}
+
+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
+}
+
+// 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 000000000..9a5da043b
--- /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 000000000..a1c472754
--- /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 100755
index 000000000..c15d13405
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/expression_vars.go
@@ -0,0 +1,72 @@
+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 *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/file.go b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/file.go
new file mode 100644
index 000000000..490c02556
--- /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 000000000..ecc389f11
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/generate.go
@@ -0,0 +1,7 @@
+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 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 000000000..eef8b9626
--- /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 000000000..8a04c2081
--- /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 zcled.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 000000000..fd426d4a6
--- /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 000000000..0f81ddfb1
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/parser.go
@@ -0,0 +1,1780 @@
+package hclsyntax
+
+import (
+	"bufio"
+	"bytes"
+	"fmt"
+
+	"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:
+		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 {
+			if !p.recovery {
+				if end.Type == TokenEOF {
+					diags = append(diags, &hcl.Diagnostic{
+						Severity: hcl.DiagError,
+						Summary:  "Missing newline after attribute definition",
+						Detail:   "A newline is required after an attribute definition at the end of a file.",
+						Subject:  &end.Range,
+						Context:  hcl.RangeBetween(ident.Range, end.Range).Ptr(),
+					})
+				} else {
+					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
+			}
+
+		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 {
+		p.Read() // eat newline
+	} else {
+		if !p.recovery {
+			if eol.Type == TokenEOF {
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Missing newline after block definition",
+					Detail:   "A newline is required after a block definition at the end of a file.",
+					Subject:  &eol.Range,
+					Context:  hcl.RangeBetween(ident.Range, eol.Range).Ptr(),
+				})
+			} else {
+				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 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()
+						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.PushIncludeNewlines(true)
+
+			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
+		}
+
+		// As a special case, we allow the key to be a literal identifier.
+		// This means that a variable reference or function call can't appear
+		// directly as key expression, and must instead be wrapped in some
+		// disambiguation punctuation, like (var.a) = "b" or "${var.a}" = "b".
+		var key Expression
+		var keyDiags hcl.Diagnostics
+		if p.Peek().Type == TokenIdent {
+			nameTok := p.Read()
+			key = &LiteralValueExpr{
+				Val: cty.StringVal(string(nameTok.Bytes)),
+
+				SrcRange: nameTok.Range,
+			}
+		} else {
+			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
+		}
+
+		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))
+	var esc []byte
+
+	sc := bufio.NewScanner(bytes.NewReader(tok.Bytes))
+	sc.Split(textseg.ScanGraphemeClusters)
+
+	pos := tok.Range.Start
+	newPos := pos
+Character:
+	for sc.Scan() {
+		pos = newPos
+		ch := sc.Bytes()
+
+		// Adjust position based on our new character.
+		// \r\n is considered to be a single character in text segmentation,
+		if (len(ch) == 1 && ch[0] == '\n') || (len(ch) == 2 && ch[1] == '\n') {
+			newPos.Line++
+			newPos.Column = 0
+		} else {
+			newPos.Column++
+		}
+		newPos.Byte += len(ch)
+
+		if len(esc) > 0 {
+			switch esc[0] {
+			case '\\':
+				if len(ch) == 1 {
+					switch ch[0] {
+
+					// TODO: numeric character escapes with \uXXXX
+
+					case 'n':
+						ret = append(ret, '\n')
+						esc = esc[:0]
+						continue Character
+					case 'r':
+						ret = append(ret, '\r')
+						esc = esc[:0]
+						continue Character
+					case 't':
+						ret = append(ret, '\t')
+						esc = esc[:0]
+						continue Character
+					case '"':
+						ret = append(ret, '"')
+						esc = esc[:0]
+						continue Character
+					case '\\':
+						ret = append(ret, '\\')
+						esc = esc[:0]
+						continue Character
+					}
+				}
+
+				var detail string
+				switch {
+				case len(ch) == 1 && (ch[0] == '$' || ch[0] == '!'):
+					detail = fmt.Sprintf(
+						"The characters \"\\%s\" do not form a recognized escape sequence. To escape a \"%s{\" template sequence, use \"%s%s{\".",
+						ch, ch, ch, ch,
+					)
+				default:
+					detail = fmt.Sprintf("The characters \"\\%s\" do not form a recognized escape sequence.", ch)
+				}
+
+				diags = append(diags, &hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Invalid escape sequence",
+					Detail:   detail,
+					Subject: &hcl.Range{
+						Filename: tok.Range.Filename,
+						Start: hcl.Pos{
+							Line:   pos.Line,
+							Column: pos.Column - 1, // safe because we know the previous character must be a backslash
+							Byte:   pos.Byte - 1,
+						},
+						End: hcl.Pos{
+							Line:   pos.Line,
+							Column: pos.Column + 1, // safe because we know the previous character must be a backslash
+							Byte:   pos.Byte + len(ch),
+						},
+					},
+				})
+				ret = append(ret, ch...)
+				esc = esc[:0]
+				continue Character
+
+			case '$', '!':
+				switch len(esc) {
+				case 1:
+					if len(ch) == 1 && ch[0] == esc[0] {
+						esc = append(esc, ch[0])
+						continue Character
+					}
+
+					// Any other character means this wasn't an escape sequence
+					// after all.
+					ret = append(ret, esc...)
+					ret = append(ret, ch...)
+					esc = esc[:0]
+				case 2:
+					if len(ch) == 1 && ch[0] == '{' {
+						// successful escape sequence
+						ret = append(ret, esc[0])
+					} else {
+						// not an escape sequence, so just output literal
+						ret = append(ret, esc...)
+					}
+					ret = append(ret, ch...)
+					esc = esc[:0]
+				default:
+					// should never happen
+					panic("have invalid escape sequence >2 characters")
+				}
+
+			}
+		} else {
+			if len(ch) == 1 {
+				switch ch[0] {
+				case '\\':
+					if quoted { // ignore backslashes in unquoted mode
+						esc = append(esc, '\\')
+						continue Character
+					}
+				case '$':
+					esc = append(esc, '$')
+					continue Character
+				case '!':
+					esc = append(esc, '!')
+					continue Character
+				}
+			}
+			ret = append(ret, ch...)
+		}
+	}
+
+	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 000000000..e04c8e0f3
--- /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 000000000..2ff3ed6c1
--- /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 000000000..b8171ffab
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/peeker.go
@@ -0,0 +1,108 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl2/hcl"
+)
+
+type peeker struct {
+	Tokens    Tokens
+	NextIndex int
+
+	IncludeComments      bool
+	IncludeNewlinesStack []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) {
+	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
+	return ret
+}
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 000000000..49d8ab182
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/public.go
@@ -0,0 +1,130 @@
+package hclsyntax
+
+import (
+	"github.com/hashicorp/hcl2/hcl"
+)
+
+// ParseConfig parses the given buffer as a whole zcl 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 *zclsyntax.Body, so callers
+// may freely type-assert this to get access to the full zclsyntax 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...)
+	return &hcl.File{
+		Body:  body,
+		Bytes: src,
+
+		Nav: navigation{
+			root: body,
+		},
+	}, diags
+}
+
+// ParseExpression parses the given buffer as a standalone zcl 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,
+		})
+	}
+
+	return expr, diags
+}
+
+// ParseTemplate parses the given buffer as a standalone zcl 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...)
+	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...)
+	return expr, diags
+}
+
+// LexConfig performs lexical analysis on the given buffer, treating it as a
+// whole zcl 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 zcl 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 zcl 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
+}
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 000000000..a8ab57c3e
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.go
@@ -0,0 +1,3779 @@
+// 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 14 "scan_tokens.go"
+var _zcltok_actions []byte = []byte{
+	0, 1, 0, 1, 2, 1, 3, 1, 4,
+	1, 5, 1, 6, 1, 7, 1, 8,
+	1, 9, 1, 10, 1, 11, 1, 12,
+	1, 13, 1, 14, 1, 15, 1, 18,
+	1, 19, 1, 20, 1, 21, 1, 22,
+	1, 23, 1, 24, 1, 25, 1, 26,
+	1, 27, 1, 30, 1, 31, 1, 32,
+	1, 33, 1, 34, 1, 35, 1, 36,
+	1, 37, 1, 38, 1, 39, 1, 45,
+	1, 46, 1, 47, 1, 48, 1, 49,
+	1, 50, 1, 51, 1, 52, 1, 53,
+	1, 54, 1, 55, 1, 56, 1, 57,
+	1, 58, 1, 59, 1, 60, 1, 61,
+	1, 62, 1, 63, 1, 64, 1, 65,
+	1, 66, 1, 67, 1, 68, 1, 69,
+	1, 70, 1, 71, 1, 72, 1, 73,
+	1, 74, 1, 75, 2, 0, 1, 2,
+	3, 16, 2, 3, 17, 2, 3, 28,
+	2, 3, 29, 2, 3, 40, 2, 3,
+	41, 2, 3, 42, 2, 3, 43, 2,
+	3, 44,
+}
+
+var _zcltok_key_offsets []int16 = []int16{
+	0, 0, 1, 2, 3, 5, 10, 14,
+	16, 57, 97, 143, 144, 148, 154, 154,
+	156, 158, 167, 173, 180, 181, 184, 185,
+	189, 194, 203, 207, 211, 219, 221, 223,
+	225, 228, 260, 262, 264, 268, 272, 275,
+	286, 299, 318, 331, 347, 359, 375, 390,
+	411, 421, 433, 444, 458, 473, 483, 495,
+	504, 516, 518, 522, 543, 552, 562, 568,
+	574, 575, 624, 626, 630, 632, 638, 645,
+	653, 660, 663, 669, 673, 677, 679, 683,
+	687, 691, 697, 705, 713, 719, 721, 725,
+	727, 733, 737, 741, 745, 749, 754, 761,
+	767, 769, 771, 775, 777, 783, 787, 791,
+	801, 806, 820, 835, 837, 845, 847, 852,
+	866, 871, 873, 877, 878, 882, 888, 894,
+	904, 914, 925, 933, 936, 939, 943, 947,
+	949, 952, 952, 955, 957, 987, 989, 991,
+	995, 1000, 1004, 1009, 1011, 1013, 1015, 1024,
+	1028, 1032, 1038, 1040, 1048, 1056, 1068, 1071,
+	1077, 1081, 1083, 1087, 1107, 1109, 1111, 1122,
+	1128, 1130, 1132, 1134, 1138, 1144, 1150, 1152,
+	1157, 1161, 1163, 1171, 1189, 1229, 1239, 1243,
+	1245, 1247, 1248, 1252, 1256, 1260, 1264, 1268,
+	1273, 1277, 1281, 1285, 1287, 1289, 1293, 1303,
+	1307, 1309, 1313, 1317, 1321, 1334, 1336, 1338,
+	1342, 1344, 1348, 1350, 1352, 1382, 1386, 1390,
+	1394, 1397, 1404, 1409, 1420, 1424, 1440, 1454,
+	1458, 1463, 1467, 1471, 1477, 1479, 1485, 1487,
+	1491, 1493, 1499, 1504, 1509, 1519, 1521, 1523,
+	1527, 1531, 1533, 1546, 1548, 1552, 1556, 1564,
+	1566, 1570, 1572, 1573, 1576, 1581, 1583, 1585,
+	1589, 1591, 1595, 1601, 1621, 1627, 1633, 1635,
+	1636, 1646, 1647, 1655, 1662, 1664, 1667, 1669,
+	1671, 1673, 1678, 1682, 1686, 1691, 1701, 1711,
+	1715, 1719, 1733, 1759, 1769, 1771, 1773, 1776,
+	1778, 1781, 1783, 1787, 1789, 1790, 1794, 1796,
+	1799, 1806, 1814, 1816, 1818, 1822, 1824, 1830,
+	1841, 1844, 1846, 1850, 1855, 1885, 1890, 1892,
+	1895, 1900, 1914, 1921, 1935, 1940, 1953, 1957,
+	1970, 1975, 1993, 1994, 2003, 2007, 2019, 2024,
+	2031, 2038, 2045, 2047, 2051, 2073, 2078, 2079,
+	2083, 2085, 2135, 2138, 2149, 2153, 2155, 2161,
+	2167, 2169, 2174, 2176, 2180, 2182, 2183, 2185,
+	2187, 2193, 2195, 2197, 2201, 2207, 2220, 2222,
+	2228, 2232, 2240, 2251, 2259, 2262, 2292, 2298,
+	2301, 2306, 2308, 2312, 2316, 2320, 2322, 2329,
+	2331, 2340, 2347, 2355, 2357, 2377, 2389, 2393,
+	2395, 2413, 2452, 2454, 2458, 2460, 2467, 2471,
+	2499, 2501, 2503, 2505, 2507, 2510, 2512, 2516,
+	2520, 2522, 2525, 2527, 2529, 2532, 2534, 2536,
+	2537, 2539, 2541, 2545, 2549, 2552, 2565, 2567,
+	2573, 2577, 2579, 2583, 2587, 2601, 2604, 2613,
+	2615, 2619, 2625, 2625, 2627, 2629, 2638, 2644,
+	2651, 2652, 2655, 2656, 2660, 2665, 2674, 2678,
+	2682, 2690, 2692, 2694, 2696, 2699, 2731, 2733,
+	2735, 2739, 2743, 2746, 2757, 2770, 2789, 2802,
+	2818, 2830, 2846, 2861, 2882, 2892, 2904, 2915,
+	2929, 2944, 2954, 2966, 2975, 2987, 2989, 2993,
+	3014, 3023, 3033, 3039, 3045, 3046, 3095, 3097,
+	3101, 3103, 3109, 3116, 3124, 3131, 3134, 3140,
+	3144, 3148, 3150, 3154, 3158, 3162, 3168, 3176,
+	3184, 3190, 3192, 3196, 3198, 3204, 3208, 3212,
+	3216, 3220, 3225, 3232, 3238, 3240, 3242, 3246,
+	3248, 3254, 3258, 3262, 3272, 3277, 3291, 3306,
+	3308, 3316, 3318, 3323, 3337, 3342, 3344, 3348,
+	3349, 3353, 3359, 3365, 3375, 3385, 3396, 3404,
+	3407, 3410, 3414, 3418, 3420, 3423, 3423, 3426,
+	3428, 3458, 3460, 3462, 3466, 3471, 3475, 3480,
+	3482, 3484, 3486, 3495, 3499, 3503, 3509, 3511,
+	3519, 3527, 3539, 3542, 3548, 3552, 3554, 3558,
+	3578, 3580, 3582, 3593, 3599, 3601, 3603, 3605,
+	3609, 3615, 3621, 3623, 3628, 3632, 3634, 3642,
+	3660, 3700, 3710, 3714, 3716, 3718, 3719, 3723,
+	3727, 3731, 3735, 3739, 3744, 3748, 3752, 3756,
+	3758, 3760, 3764, 3774, 3778, 3780, 3784, 3788,
+	3792, 3805, 3807, 3809, 3813, 3815, 3819, 3821,
+	3823, 3853, 3857, 3861, 3865, 3868, 3875, 3880,
+	3891, 3895, 3911, 3925, 3929, 3934, 3938, 3942,
+	3948, 3950, 3956, 3958, 3962, 3964, 3970, 3975,
+	3980, 3990, 3992, 3994, 3998, 4002, 4004, 4017,
+	4019, 4023, 4027, 4035, 4037, 4041, 4043, 4044,
+	4047, 4052, 4054, 4056, 4060, 4062, 4066, 4072,
+	4092, 4098, 4104, 4106, 4107, 4117, 4118, 4126,
+	4133, 4135, 4138, 4140, 4142, 4144, 4149, 4153,
+	4157, 4162, 4172, 4182, 4186, 4190, 4204, 4230,
+	4240, 4242, 4244, 4247, 4249, 4252, 4254, 4258,
+	4260, 4261, 4265, 4267, 4269, 4276, 4280, 4287,
+	4294, 4303, 4319, 4331, 4349, 4360, 4372, 4380,
+	4398, 4406, 4436, 4439, 4449, 4459, 4471, 4482,
+	4491, 4504, 4516, 4520, 4526, 4553, 4562, 4565,
+	4570, 4576, 4581, 4602, 4606, 4612, 4612, 4619,
+	4628, 4636, 4639, 4643, 4649, 4655, 4658, 4662,
+	4669, 4675, 4684, 4693, 4697, 4701, 4705, 4709,
+	4716, 4720, 4724, 4734, 4740, 4744, 4750, 4754,
+	4757, 4763, 4769, 4781, 4785, 4789, 4799, 4803,
+	4814, 4816, 4818, 4822, 4834, 4839, 4863, 4867,
+	4873, 4895, 4904, 4908, 4911, 4912, 4920, 4928,
+	4934, 4944, 4951, 4969, 4972, 4975, 4983, 4989,
+	4993, 4997, 5001, 5007, 5015, 5020, 5026, 5030,
+	5038, 5045, 5049, 5056, 5062, 5070, 5078, 5084,
+	5090, 5101, 5105, 5117, 5126, 5143, 5160, 5163,
+	5167, 5169, 5175, 5177, 5181, 5196, 5200, 5204,
+	5208, 5212, 5216, 5218, 5224, 5229, 5233, 5239,
+	5246, 5249, 5267, 5269, 5314, 5320, 5326, 5330,
+	5334, 5340, 5344, 5350, 5356, 5363, 5365, 5371,
+	5377, 5381, 5385, 5393, 5406, 5412, 5419, 5427,
+	5433, 5442, 5448, 5452, 5457, 5461, 5469, 5473,
+	5477, 5507, 5513, 5519, 5525, 5531, 5538, 5544,
+	5551, 5556, 5566, 5570, 5577, 5583, 5587, 5594,
+	5598, 5604, 5607, 5611, 5615, 5619, 5623, 5628,
+	5633, 5637, 5648, 5652, 5656, 5662, 5670, 5674,
+	5691, 5695, 5701, 5711, 5717, 5723, 5726, 5731,
+	5740, 5744, 5748, 5754, 5758, 5764, 5772, 5790,
+	5791, 5801, 5802, 5811, 5819, 5821, 5824, 5826,
+	5828, 5830, 5835, 5848, 5852, 5867, 5896, 5907,
+	5909, 5913, 5917, 5922, 5926, 5928, 5935, 5939,
+	5947, 5951, 5952, 5954, 5956, 5958, 5960, 5962,
+	5963, 5964, 5966, 5968, 5970, 5971, 5972, 5973,
+	5974, 5976, 5978, 5980, 5981, 5982, 6057, 6058,
+	6059, 6060, 6061, 6062, 6063, 6064, 6066, 6067,
+	6072, 6074, 6076, 6077, 6121, 6122, 6123, 6125,
+	6130, 6134, 6134, 6136, 6138, 6149, 6159, 6167,
+	6168, 6170, 6171, 6175, 6179, 6189, 6193, 6200,
+	6211, 6218, 6222, 6228, 6239, 6271, 6320, 6335,
+	6350, 6355, 6357, 6362, 6394, 6402, 6404, 6426,
+	6448, 6450, 6466, 6482, 6497, 6506, 6520, 6534,
+	6550, 6551, 6552, 6553, 6554, 6556, 6558, 6560,
+	6574, 6588, 6589, 6590, 6592, 6594, 6596, 6610,
+	6624, 6625, 6626, 6628, 6630,
+}
+
+var _zcltok_trans_keys []byte = []byte{
+	10, 46, 42, 42, 47, 46, 69, 101,
+	48, 57, 43, 45, 48, 57, 48, 57,
+	45, 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, 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,
+	128, 191, 128, 191, 128, 191, 128, 191,
+	128, 191, 10, 123, 128, 191, 128, 191,
+	128, 191, 123, 123, 10, 123, 128, 191,
+	128, 191, 128, 191, 123, 123, 9, 10,
+	13, 32, 33, 34, 35, 38, 46, 47,
+	60, 61, 62, 64, 92, 95, 123, 124,
+	125, 126, 127, 194, 195, 198, 199, 203,
+	204, 205, 206, 207, 210, 212, 213, 214,
+	215, 216, 217, 219, 220, 221, 222, 223,
+	224, 225, 226, 227, 228, 233, 234, 237,
+	238, 239, 240, 0, 39, 40, 45, 48,
+	57, 58, 63, 65, 90, 91, 96, 97,
+	122, 192, 193, 196, 218, 229, 236, 241,
+	247, 9, 10, 32, 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, 92, 36, 37,
+	128, 191, 192, 223, 224, 239, 240, 247,
+	248, 255, 10, 13, 92, 36, 37, 128,
+	191, 192, 223, 224, 239, 240, 247, 248,
+	255, 92, 36, 37, 192, 223, 224, 239,
+	240, 247, 10, 13, 34, 92, 36, 37,
+	192, 223, 224, 239, 240, 247, 248, 255,
+	10, 13, 34, 92, 36, 37, 128, 223,
+	224, 239, 240, 247, 248, 255, 10, 13,
+	34, 92, 36, 37, 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, 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,
+}
+
+var _zcltok_single_lengths []byte = []byte{
+	0, 1, 1, 1, 2, 3, 2, 0,
+	31, 30, 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, 0, 0, 0, 0, 0, 1,
+	1, 0, 0, 0, 1, 1, 1, 1,
+	0, 0, 0, 1, 1, 53, 1, 1,
+	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, 4, 3, 1, 4, 4, 4,
+	1, 1, 1, 1, 0, 0, 0, 4,
+	2, 1, 1, 0, 0, 0, 4, 2,
+	1, 1, 0, 0, 0,
+}
+
+var _zcltok_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, 1, 1, 1, 1, 1, 0,
+	0, 1, 1, 1, 0, 0, 0, 0,
+	1, 1, 1, 0, 0, 11, 0, 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, 6, 6, 4, 5, 5, 6,
+	0, 0, 0, 0, 1, 1, 1, 5,
+	6, 0, 0, 1, 1, 1, 5, 6,
+	0, 0, 1, 1, 1,
+}
+
+var _zcltok_index_offsets []int16 = []int16{
+	0, 0, 2, 4, 6, 9, 14, 18,
+	20, 57, 93, 135, 137, 142, 146, 147,
+	149, 151, 157, 162, 167, 169, 172, 174,
+	177, 181, 187, 190, 193, 199, 201, 203,
+	205, 208, 241, 243, 245, 248, 251, 254,
+	262, 270, 281, 289, 298, 306, 315, 324,
+	336, 343, 350, 358, 366, 375, 381, 389,
+	395, 403, 405, 408, 422, 428, 436, 440,
+	444, 446, 493, 495, 498, 500, 505, 511,
+	517, 522, 525, 529, 532, 535, 537, 540,
+	543, 546, 550, 555, 560, 564, 566, 569,
+	571, 575, 578, 581, 584, 587, 591, 596,
+	600, 602, 604, 607, 609, 613, 616, 619,
+	627, 631, 639, 655, 657, 662, 664, 668,
+	679, 683, 685, 688, 690, 693, 698, 702,
+	708, 714, 725, 730, 733, 736, 739, 742,
+	744, 748, 749, 752, 754, 784, 786, 788,
+	791, 795, 798, 802, 804, 806, 808, 814,
+	817, 820, 824, 826, 831, 836, 843, 846,
+	850, 854, 856, 859, 879, 881, 883, 890,
+	894, 896, 898, 900, 903, 907, 911, 913,
+	917, 920, 922, 927, 945, 984, 990, 993,
+	995, 997, 999, 1002, 1005, 1008, 1011, 1014,
+	1018, 1021, 1024, 1027, 1029, 1031, 1034, 1041,
+	1044, 1046, 1049, 1052, 1055, 1063, 1065, 1067,
+	1070, 1072, 1075, 1077, 1079, 1109, 1112, 1115,
+	1118, 1121, 1126, 1130, 1137, 1140, 1149, 1158,
+	1161, 1165, 1168, 1171, 1175, 1177, 1181, 1183,
+	1186, 1188, 1192, 1196, 1200, 1208, 1210, 1212,
+	1216, 1220, 1222, 1235, 1237, 1240, 1243, 1248,
+	1250, 1253, 1255, 1257, 1260, 1265, 1267, 1269,
+	1274, 1276, 1279, 1283, 1303, 1307, 1311, 1313,
+	1315, 1323, 1325, 1332, 1337, 1339, 1343, 1346,
+	1349, 1352, 1356, 1359, 1362, 1366, 1376, 1382,
+	1385, 1388, 1398, 1418, 1424, 1427, 1429, 1433,
+	1435, 1438, 1440, 1444, 1446, 1448, 1452, 1454,
+	1458, 1463, 1469, 1471, 1473, 1476, 1478, 1482,
+	1489, 1492, 1494, 1497, 1501, 1531, 1536, 1538,
+	1541, 1545, 1554, 1559, 1567, 1571, 1579, 1583,
+	1591, 1595, 1606, 1608, 1614, 1617, 1625, 1629,
+	1634, 1639, 1644, 1646, 1649, 1664, 1668, 1670,
+	1673, 1675, 1724, 1727, 1734, 1737, 1739, 1743,
+	1747, 1750, 1754, 1756, 1759, 1761, 1763, 1765,
+	1767, 1771, 1773, 1775, 1778, 1782, 1796, 1799,
+	1803, 1806, 1811, 1822, 1827, 1830, 1860, 1864,
+	1867, 1872, 1874, 1878, 1881, 1884, 1886, 1891,
+	1893, 1899, 1904, 1910, 1912, 1932, 1940, 1943,
+	1945, 1963, 2001, 2003, 2006, 2008, 2013, 2016,
+	2045, 2047, 2049, 2051, 2053, 2056, 2058, 2062,
+	2065, 2067, 2070, 2072, 2074, 2077, 2079, 2081,
+	2083, 2085, 2087, 2090, 2093, 2096, 2109, 2111,
+	2115, 2118, 2120, 2125, 2128, 2142, 2145, 2154,
+	2156, 2161, 2165, 2166, 2168, 2170, 2176, 2181,
+	2186, 2188, 2191, 2193, 2196, 2200, 2206, 2209,
+	2212, 2218, 2220, 2222, 2224, 2227, 2260, 2262,
+	2264, 2267, 2270, 2273, 2281, 2289, 2300, 2308,
+	2317, 2325, 2334, 2343, 2355, 2362, 2369, 2377,
+	2385, 2394, 2400, 2408, 2414, 2422, 2424, 2427,
+	2441, 2447, 2455, 2459, 2463, 2465, 2512, 2514,
+	2517, 2519, 2524, 2530, 2536, 2541, 2544, 2548,
+	2551, 2554, 2556, 2559, 2562, 2565, 2569, 2574,
+	2579, 2583, 2585, 2588, 2590, 2594, 2597, 2600,
+	2603, 2606, 2610, 2615, 2619, 2621, 2623, 2626,
+	2628, 2632, 2635, 2638, 2646, 2650, 2658, 2674,
+	2676, 2681, 2683, 2687, 2698, 2702, 2704, 2707,
+	2709, 2712, 2717, 2721, 2727, 2733, 2744, 2749,
+	2752, 2755, 2758, 2761, 2763, 2767, 2768, 2771,
+	2773, 2803, 2805, 2807, 2810, 2814, 2817, 2821,
+	2823, 2825, 2827, 2833, 2836, 2839, 2843, 2845,
+	2850, 2855, 2862, 2865, 2869, 2873, 2875, 2878,
+	2898, 2900, 2902, 2909, 2913, 2915, 2917, 2919,
+	2922, 2926, 2930, 2932, 2936, 2939, 2941, 2946,
+	2964, 3003, 3009, 3012, 3014, 3016, 3018, 3021,
+	3024, 3027, 3030, 3033, 3037, 3040, 3043, 3046,
+	3048, 3050, 3053, 3060, 3063, 3065, 3068, 3071,
+	3074, 3082, 3084, 3086, 3089, 3091, 3094, 3096,
+	3098, 3128, 3131, 3134, 3137, 3140, 3145, 3149,
+	3156, 3159, 3168, 3177, 3180, 3184, 3187, 3190,
+	3194, 3196, 3200, 3202, 3205, 3207, 3211, 3215,
+	3219, 3227, 3229, 3231, 3235, 3239, 3241, 3254,
+	3256, 3259, 3262, 3267, 3269, 3272, 3274, 3276,
+	3279, 3284, 3286, 3288, 3293, 3295, 3298, 3302,
+	3322, 3326, 3330, 3332, 3334, 3342, 3344, 3351,
+	3356, 3358, 3362, 3365, 3368, 3371, 3375, 3378,
+	3381, 3385, 3395, 3401, 3404, 3407, 3417, 3437,
+	3443, 3446, 3448, 3452, 3454, 3457, 3459, 3463,
+	3465, 3467, 3471, 3473, 3475, 3481, 3484, 3489,
+	3494, 3500, 3510, 3518, 3530, 3537, 3547, 3553,
+	3565, 3571, 3589, 3592, 3600, 3606, 3616, 3623,
+	3630, 3638, 3646, 3649, 3654, 3674, 3680, 3683,
+	3687, 3691, 3695, 3707, 3710, 3715, 3716, 3722,
+	3729, 3735, 3738, 3741, 3745, 3749, 3752, 3755,
+	3760, 3764, 3770, 3776, 3779, 3783, 3786, 3789,
+	3794, 3797, 3800, 3806, 3810, 3813, 3817, 3820,
+	3823, 3827, 3831, 3838, 3841, 3844, 3850, 3853,
+	3860, 3862, 3864, 3867, 3876, 3881, 3895, 3899,
+	3903, 3918, 3924, 3927, 3930, 3932, 3937, 3943,
+	3947, 3955, 3961, 3971, 3974, 3977, 3982, 3986,
+	3989, 3992, 3995, 3999, 4004, 4008, 4012, 4015,
+	4020, 4025, 4028, 4034, 4038, 4044, 4049, 4053,
+	4057, 4065, 4068, 4076, 4082, 4092, 4103, 4106,
+	4109, 4111, 4115, 4117, 4120, 4131, 4135, 4138,
+	4141, 4144, 4147, 4149, 4153, 4157, 4160, 4164,
+	4169, 4172, 4182, 4184, 4225, 4231, 4235, 4238,
+	4241, 4245, 4248, 4252, 4256, 4261, 4263, 4267,
+	4271, 4274, 4277, 4282, 4291, 4295, 4300, 4305,
+	4309, 4316, 4320, 4323, 4327, 4330, 4335, 4338,
+	4341, 4371, 4375, 4379, 4383, 4387, 4392, 4396,
+	4402, 4406, 4414, 4417, 4422, 4426, 4429, 4434,
+	4437, 4441, 4444, 4447, 4450, 4453, 4456, 4460,
+	4464, 4467, 4477, 4480, 4483, 4488, 4494, 4497,
+	4512, 4515, 4519, 4525, 4529, 4533, 4536, 4540,
+	4547, 4550, 4553, 4559, 4562, 4566, 4571, 4587,
+	4589, 4597, 4599, 4607, 4613, 4615, 4619, 4622,
+	4625, 4628, 4632, 4643, 4646, 4658, 4682, 4690,
+	4692, 4696, 4699, 4704, 4707, 4709, 4714, 4717,
+	4723, 4726, 4728, 4730, 4732, 4734, 4736, 4738,
+	4740, 4742, 4744, 4746, 4748, 4750, 4752, 4754,
+	4756, 4758, 4760, 4762, 4764, 4766, 4831, 4833,
+	4835, 4837, 4839, 4841, 4843, 4845, 4848, 4850,
+	4855, 4858, 4861, 4863, 4903, 4905, 4907, 4909,
+	4914, 4918, 4919, 4921, 4923, 4930, 4937, 4944,
+	4946, 4948, 4950, 4953, 4956, 4962, 4965, 4970,
+	4977, 4982, 4985, 4989, 4996, 5028, 5077, 5092,
+	5105, 5110, 5112, 5116, 5147, 5153, 5155, 5176,
+	5196, 5198, 5210, 5221, 5231, 5237, 5247, 5257,
+	5268, 5270, 5272, 5274, 5276, 5278, 5280, 5282,
+	5292, 5301, 5303, 5305, 5307, 5309, 5311, 5321,
+	5330, 5332, 5334, 5336, 5338,
+}
+
+var _zcltok_indicies []int16 = []int16{
+	2, 1, 4, 3, 6, 5, 6, 7,
+	5, 9, 11, 11, 10, 8, 12, 12,
+	10, 8, 10, 8, 13, 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, 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,
+	769, 768, 770, 768, 771, 768, 769, 772,
+	773, 772, 775, 774, 776, 777, 777, 774,
+	778, 774, 779, 776, 780, 777, 781, 777,
+	783, 782, 784, 785, 785, 782, 786, 782,
+	787, 784, 788, 785, 789, 785, 790, 791,
+	792, 793, 794, 795, 796, 797, 799, 800,
+	801, 802, 803, 672, 672, 672, 804, 805,
+	806, 807, 672, 810, 811, 813, 814, 815,
+	809, 816, 817, 818, 819, 820, 821, 822,
+	823, 824, 825, 826, 827, 828, 829, 830,
+	831, 832, 833, 834, 835, 837, 838, 839,
+	840, 841, 842, 672, 798, 10, 798, 422,
+	798, 422, 809, 812, 836, 843, 808, 790,
+	844, 791, 845, 793, 846, 848, 847, 2,
+	1, 849, 847, 850, 847, 5, 1, 847,
+	6, 5, 9, 11, 11, 10, 852, 853,
+	854, 847, 855, 856, 847, 857, 847, 422,
+	422, 859, 860, 491, 472, 861, 472, 862,
+	863, 864, 865, 866, 867, 868, 869, 870,
+	871, 872, 546, 873, 522, 874, 875, 876,
+	877, 878, 879, 880, 881, 882, 883, 884,
+	885, 422, 422, 422, 427, 567, 858, 886,
+	847, 887, 847, 672, 888, 422, 422, 422,
+	672, 888, 672, 672, 422, 888, 422, 888,
+	422, 888, 422, 672, 672, 672, 672, 672,
+	888, 422, 672, 672, 672, 422, 672, 422,
+	888, 422, 672, 672, 672, 672, 422, 888,
+	672, 422, 672, 422, 672, 422, 672, 672,
+	422, 672, 888, 422, 672, 422, 672, 422,
+	672, 888, 672, 422, 888, 672, 422, 672,
+	422, 888, 672, 672, 672, 672, 672, 888,
+	422, 422, 672, 422, 672, 888, 672, 422,
+	888, 672, 672, 888, 422, 422, 672, 422,
+	672, 422, 672, 888, 889, 890, 891, 892,
+	893, 894, 895, 896, 897, 898, 899, 717,
+	900, 901, 902, 903, 904, 905, 906, 907,
+	908, 909, 910, 911, 910, 912, 913, 914,
+	915, 916, 673, 888, 917, 918, 919, 920,
+	921, 922, 923, 924, 925, 926, 927, 928,
+	929, 930, 931, 932, 933, 934, 935, 727,
+	936, 937, 938, 694, 939, 940, 941, 942,
+	943, 944, 673, 945, 946, 947, 948, 949,
+	950, 951, 952, 676, 953, 673, 676, 954,
+	955, 956, 957, 685, 888, 958, 959, 960,
+	961, 705, 962, 963, 685, 964, 965, 966,
+	967, 968, 673, 888, 969, 928, 970, 971,
+	972, 685, 973, 974, 676, 673, 685, 427,
+	888, 938, 673, 676, 685, 427, 685, 427,
+	975, 685, 888, 427, 676, 976, 977, 676,
+	978, 979, 683, 980, 981, 982, 983, 984,
+	934, 985, 986, 987, 988, 989, 990, 991,
+	992, 993, 994, 995, 996, 953, 997, 676,
+	685, 427, 888, 998, 999, 685, 673, 888,
+	427, 673, 888, 676, 1000, 733, 1001, 1002,
+	1003, 1004, 1005, 1006, 1007, 1008, 673, 1009,
+	1010, 1011, 1012, 1013, 1014, 673, 685, 888,
+	1016, 1017, 1018, 1019, 1020, 1021, 1022, 1023,
+	1024, 1025, 1026, 1022, 1028, 1029, 1030, 1031,
+	1015, 1027, 1015, 888, 1015, 888, 1032, 1032,
+	1033, 1034, 1035, 1036, 1037, 1038, 1039, 1040,
+	1037, 769, 1041, 1041, 1041, 1036, 1042, 1041,
+	770, 771, 1043, 1041, 769, 1041, 1041, 1036,
+	1044, 1041, 770, 771, 1043, 1041, 769, 1036,
+	1044, 1045, 1046, 1047, 769, 1041, 1041, 1041,
+	1036, 1042, 770, 771, 1043, 1041, 769, 1041,
+	1041, 1041, 1036, 1042, 770, 771, 1043, 1041,
+	769, 1041, 1041, 1041, 1036, 1042, 771, 770,
+	771, 1043, 1041, 769, 1049, 769, 1051, 1050,
+	1052, 769, 1054, 1053, 769, 1055, 773, 1055,
+	1056, 1055, 775, 1057, 1058, 1059, 1060, 1061,
+	1062, 1063, 1060, 777, 775, 1057, 1065, 1064,
+	778, 779, 1066, 1064, 777, 1068, 1067, 1070,
+	1069, 777, 1071, 778, 1071, 779, 1071, 783,
+	1072, 1073, 1074, 1075, 1076, 1077, 1078, 1075,
+	785, 783, 1072, 1080, 1079, 786, 787, 1081,
+	1079, 785, 1083, 1082, 1085, 1084, 785, 1086,
+	786, 1086, 787, 1086,
+}
+
+var _zcltok_trans_targs []int16 = []int16{
+	949, 1, 949, 949, 949, 3, 4, 958,
+	949, 5, 959, 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, 949,
+	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, 949, 963, 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, 949,
+	949, 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,
+	1001, 1002, 930, 931, 1001, 933, 1015, 1015,
+	1015, 1016, 937, 938, 1017, 1018, 1022, 1022,
+	1022, 1023, 944, 945, 1024, 1025, 950, 949,
+	951, 952, 953, 949, 954, 955, 949, 956,
+	957, 960, 961, 962, 949, 964, 949, 965,
+	949, 966, 967, 968, 969, 970, 971, 972,
+	973, 974, 975, 976, 977, 978, 979, 980,
+	981, 982, 983, 984, 985, 986, 987, 988,
+	989, 990, 991, 992, 993, 994, 995, 996,
+	997, 998, 999, 1000, 949, 949, 949, 949,
+	949, 949, 2, 949, 949, 8, 949, 949,
+	949, 949, 949, 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, 949, 949,
+	949, 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,
+	1001, 1001, 1008, 1010, 1003, 1001, 1012, 1013,
+	1014, 1001, 929, 932, 1004, 1005, 1006, 1007,
+	1001, 1009, 1001, 1001, 1011, 1001, 1001, 1001,
+	934, 935, 940, 941, 1015, 1019, 1020, 1021,
+	1015, 936, 939, 1015, 1015, 1015, 1015, 1015,
+	942, 947, 948, 1022, 1026, 1027, 1028, 1022,
+	943, 946, 1022, 1022, 1022, 1022, 1022,
+}
+
+var _zcltok_trans_actions []byte = []byte{
+	131, 0, 71, 127, 87, 0, 0, 151,
+	123, 0, 5, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 101,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 125, 148, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 129,
+	105, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	27, 5, 0, 0, 29, 0, 49, 35,
+	47, 136, 0, 0, 0, 0, 69, 55,
+	67, 142, 0, 0, 0, 0, 0, 73,
+	0, 0, 0, 99, 160, 0, 91, 5,
+	154, 5, 0, 0, 93, 0, 95, 0,
+	103, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 5,
+	5, 5, 157, 157, 157, 157, 157, 157,
+	5, 5, 157, 5, 117, 121, 107, 115,
+	77, 83, 0, 113, 109, 0, 81, 75,
+	89, 79, 111, 0, 0, 0, 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, 97,
+	119, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	13, 11, 0, 0, 5, 15, 0, 5,
+	5, 21, 0, 0, 0, 5, 5, 5,
+	23, 0, 17, 7, 0, 19, 9, 25,
+	0, 0, 0, 0, 37, 0, 139, 139,
+	43, 0, 0, 39, 31, 41, 33, 45,
+	0, 0, 0, 57, 0, 145, 145, 63,
+	0, 0, 59, 51, 61, 53, 65,
+}
+
+var _zcltok_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, 1, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 1, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 133,
+	0, 0, 0, 0, 0, 0, 133, 0,
+	0, 0, 0, 0, 0,
+}
+
+var _zcltok_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, 3, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 0,
+	0, 3, 0, 0, 0, 0, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 3,
+	0, 0, 0, 0, 0, 0, 3, 0,
+	0, 0, 0, 0, 0,
+}
+
+var _zcltok_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, 773, 773, 775,
+	777, 775, 775, 777, 0, 0, 783, 785,
+	783, 783, 785, 0, 0, 0, 845, 846,
+	847, 848, 846, 848, 848, 848, 852, 853,
+	848, 848, 848, 859, 848, 848, 889, 889,
+	889, 889, 889, 889, 889, 889, 889, 889,
+	889, 889, 889, 889, 889, 889, 889, 889,
+	889, 889, 889, 889, 889, 889, 889, 889,
+	889, 889, 889, 889, 889, 889, 889, 889,
+	889, 0, 1042, 1042, 1042, 1042, 1042, 1042,
+	1049, 1051, 1049, 1054, 1056, 1056, 1056, 0,
+	1065, 1068, 1070, 1072, 1072, 1072, 0, 1080,
+	1083, 1085, 1087, 1087, 1087,
+}
+
+const zcltok_start int = 949
+const zcltok_first_final int = 949
+const zcltok_error int = 0
+
+const zcltok_en_stringTemplate int = 1001
+const zcltok_en_heredocTemplate int = 1015
+const zcltok_en_bareTemplate int = 1022
+const zcltok_en_main int = 949
+
+// line 15 "scan_tokens.rl"
+
+func scanTokens(data []byte, filename string, start hcl.Pos, mode scanMode) []Token {
+	f := &tokenAccum{
+		Filename: filename,
+		Bytes:    data,
+		Pos:      start,
+	}
+
+	// line 272 "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 = zcltok_en_main
+	case scanTemplate:
+		cs = zcltok_en_bareTemplate
+	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 305 "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 2816 "scan_tokens.go"
+	{
+		top = 0
+		ts = 0
+		te = 0
+		act = 0
+	}
+
+	// line 2824 "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(_zcltok_from_state_actions[cs])
+		_nacts = uint(_zcltok_actions[_acts])
+		_acts++
+		for ; _nacts > 0; _nacts-- {
+			_acts++
+			switch _zcltok_actions[_acts-1] {
+			case 2:
+				// line 1 "NONE"
+
+				ts = p
+
+				// line 2848 "scan_tokens.go"
+			}
+		}
+
+		_keys = int(_zcltok_key_offsets[cs])
+		_trans = int(_zcltok_index_offsets[cs])
+
+		_klen = int(_zcltok_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] < _zcltok_trans_keys[_mid]:
+					_upper = _mid - 1
+				case data[p] > _zcltok_trans_keys[_mid]:
+					_lower = _mid + 1
+				default:
+					_trans += int(_mid - int(_keys))
+					goto _match
+				}
+			}
+			_keys += _klen
+			_trans += _klen
+		}
+
+		_klen = int(_zcltok_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] < _zcltok_trans_keys[_mid]:
+					_upper = _mid - 2
+				case data[p] > _zcltok_trans_keys[_mid+1]:
+					_lower = _mid + 2
+				default:
+					_trans += int((_mid - int(_keys)) >> 1)
+					goto _match
+				}
+			}
+			_trans += _klen
+		}
+
+	_match:
+		_trans = int(_zcltok_indicies[_trans])
+	_eof_trans:
+		cs = int(_zcltok_trans_targs[_trans])
+
+		if _zcltok_trans_actions[_trans] == 0 {
+			goto _again
+		}
+
+		_acts = int(_zcltok_trans_actions[_trans])
+		_nacts = uint(_zcltok_actions[_acts])
+		_acts++
+		for ; _nacts > 0; _nacts-- {
+			_acts++
+			switch _zcltok_actions[_acts-1] {
+			case 3:
+				// line 1 "NONE"
+
+				te = p + 1
+
+			case 4:
+				// line 138 "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 = 949
+						goto _again
+					}
+				}
+			case 5:
+				// line 148 "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 = 949
+						goto _again
+					}
+				}
+			case 6:
+				// line 80 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenCQuote)
+					top--
+					cs = stack[top]
+					{
+						stack = stack[:len(stack)-1]
+					}
+					goto _again
+
+				}
+			case 7:
+				// line 222 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenInvalid)
+				}
+			case 8:
+				// line 223 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 9:
+				// line 138 "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 = 949
+						goto _again
+					}
+				}
+			case 10:
+				// line 148 "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 = 949
+						goto _again
+					}
+				}
+			case 11:
+				// line 221 "scan_tokens.rl"
+
+				te = p
+				p--
+				{
+					token(TokenQuotedLit)
+				}
+			case 12:
+				// line 222 "scan_tokens.rl"
+
+				te = p
+				p--
+				{
+					token(TokenInvalid)
+				}
+			case 13:
+				// line 223 "scan_tokens.rl"
+
+				te = p
+				p--
+				{
+					token(TokenBadUTF8)
+				}
+			case 14:
+				// line 221 "scan_tokens.rl"
+
+				p = (te) - 1
+				{
+					token(TokenQuotedLit)
+				}
+			case 15:
+				// line 223 "scan_tokens.rl"
+
+				p = (te) - 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 16:
+				// line 126 "scan_tokens.rl"
+
+				act = 10
+			case 17:
+				// line 231 "scan_tokens.rl"
+
+				act = 11
+			case 18:
+				// line 138 "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 = 949
+						goto _again
+					}
+				}
+			case 19:
+				// line 148 "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 = 949
+						goto _again
+					}
+				}
+			case 20:
+				// line 107 "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) {
+							token(TokenCHeredoc)
+							heredocs = heredocs[:len(heredocs)-1]
+							top--
+							cs = stack[top]
+							{
+								stack = stack[:len(stack)-1]
+							}
+							goto _again
+
+						}
+					}
+
+					topdoc.StartOfLine = true
+					token(TokenStringLit)
+				}
+			case 21:
+				// line 231 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 22:
+				// line 138 "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 = 949
+						goto _again
+					}
+				}
+			case 23:
+				// line 148 "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 = 949
+						goto _again
+					}
+				}
+			case 24:
+				// line 126 "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 25:
+				// line 231 "scan_tokens.rl"
+
+				te = p
+				p--
+				{
+					token(TokenBadUTF8)
+				}
+			case 26:
+				// line 126 "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 27:
+				// 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 28:
+				// line 134 "scan_tokens.rl"
+
+				act = 14
+			case 29:
+				// line 238 "scan_tokens.rl"
+
+				act = 15
+			case 30:
+				// line 138 "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 = 949
+						goto _again
+					}
+				}
+			case 31:
+				// line 148 "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 = 949
+						goto _again
+					}
+				}
+			case 32:
+				// line 134 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenStringLit)
+				}
+			case 33:
+				// line 238 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 34:
+				// line 138 "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 = 949
+						goto _again
+					}
+				}
+			case 35:
+				// line 148 "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 = 949
+						goto _again
+					}
+				}
+			case 36:
+				// line 134 "scan_tokens.rl"
+
+				te = p
+				p--
+				{
+					token(TokenStringLit)
+				}
+			case 37:
+				// line 238 "scan_tokens.rl"
+
+				te = p
+				p--
+				{
+					token(TokenBadUTF8)
+				}
+			case 38:
+				// line 134 "scan_tokens.rl"
+
+				p = (te) - 1
+				{
+					token(TokenStringLit)
+				}
+			case 39:
+				// 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 40:
+				// line 244 "scan_tokens.rl"
+
+				act = 18
+			case 41:
+				// line 246 "scan_tokens.rl"
+
+				act = 19
+			case 42:
+				// line 257 "scan_tokens.rl"
+
+				act = 29
+			case 43:
+				// line 268 "scan_tokens.rl"
+
+				act = 36
+			case 44:
+				// line 269 "scan_tokens.rl"
+
+				act = 37
+			case 45:
+				// line 246 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenComment)
+				}
+			case 46:
+				// line 247 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenNewline)
+				}
+			case 47:
+				// line 249 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenEqualOp)
+				}
+			case 48:
+				// line 250 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenNotEqual)
+				}
+			case 49:
+				// line 251 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenGreaterThanEq)
+				}
+			case 50:
+				// line 252 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenLessThanEq)
+				}
+			case 51:
+				// line 253 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenAnd)
+				}
+			case 52:
+				// line 254 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenOr)
+				}
+			case 53:
+				// line 255 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenEllipsis)
+				}
+			case 54:
+				// line 256 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenFatArrow)
+				}
+			case 55:
+				// line 257 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					selfToken()
+				}
+			case 56:
+				// line 158 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenOBrace)
+					braces++
+				}
+			case 57:
+				// line 163 "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 58:
+				// line 175 "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 59:
+				// line 75 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenOQuote)
+					{
+						stack = append(stack, 0)
+						stack[top] = cs
+						top++
+						cs = 1001
+						goto _again
+					}
+				}
+			case 60:
+				// line 85 "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 = 1015
+						goto _again
+					}
+				}
+			case 61:
+				// line 268 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 62:
+				// line 269 "scan_tokens.rl"
+
+				te = p + 1
+				{
+					token(TokenInvalid)
+				}
+			case 63:
+				// line 242 "scan_tokens.rl"
+
+				te = p
+				p--
+
+			case 64:
+				// line 243 "scan_tokens.rl"
+
+				te = p
+				p--
+				{
+					token(TokenNumberLit)
+				}
+			case 65:
+				// line 244 "scan_tokens.rl"
+
+				te = p
+				p--
+				{
+					token(TokenIdent)
+				}
+			case 66:
+				// line 246 "scan_tokens.rl"
+
+				te = p
+				p--
+				{
+					token(TokenComment)
+				}
+			case 67:
+				// line 257 "scan_tokens.rl"
+
+				te = p
+				p--
+				{
+					selfToken()
+				}
+			case 68:
+				// line 267 "scan_tokens.rl"
+
+				te = p
+				p--
+				{
+					token(TokenTabs)
+				}
+			case 69:
+				// line 268 "scan_tokens.rl"
+
+				te = p
+				p--
+				{
+					token(TokenBadUTF8)
+				}
+			case 70:
+				// line 269 "scan_tokens.rl"
+
+				te = p
+				p--
+				{
+					token(TokenInvalid)
+				}
+			case 71:
+				// line 243 "scan_tokens.rl"
+
+				p = (te) - 1
+				{
+					token(TokenNumberLit)
+				}
+			case 72:
+				// line 244 "scan_tokens.rl"
+
+				p = (te) - 1
+				{
+					token(TokenIdent)
+				}
+			case 73:
+				// line 257 "scan_tokens.rl"
+
+				p = (te) - 1
+				{
+					selfToken()
+				}
+			case 74:
+				// line 268 "scan_tokens.rl"
+
+				p = (te) - 1
+				{
+					token(TokenBadUTF8)
+				}
+			case 75:
+				// line 1 "NONE"
+
+				switch act {
+				case 18:
+					{
+						p = (te) - 1
+						token(TokenIdent)
+					}
+				case 19:
+					{
+						p = (te) - 1
+						token(TokenComment)
+					}
+				case 29:
+					{
+						p = (te) - 1
+						selfToken()
+					}
+				case 36:
+					{
+						p = (te) - 1
+						token(TokenBadUTF8)
+					}
+				case 37:
+					{
+						p = (te) - 1
+						token(TokenInvalid)
+					}
+				}
+
+				// line 3592 "scan_tokens.go"
+			}
+		}
+
+	_again:
+		_acts = int(_zcltok_to_state_actions[cs])
+		_nacts = uint(_zcltok_actions[_acts])
+		_acts++
+		for ; _nacts > 0; _nacts-- {
+			_acts++
+			switch _zcltok_actions[_acts-1] {
+			case 0:
+				// line 1 "NONE"
+
+				ts = 0
+
+			case 1:
+				// line 1 "NONE"
+
+				act = 0
+
+				// line 3612 "scan_tokens.go"
+			}
+		}
+
+		if cs == 0 {
+			goto _out
+		}
+		p++
+		if p != pe {
+			goto _resume
+		}
+	_test_eof:
+		{
+		}
+		if p == eof {
+			if _zcltok_eof_trans[cs] > 0 {
+				_trans = int(_zcltok_eof_trans[cs] - 1)
+				goto _eof_trans
+			}
+		}
+
+	_out:
+		{
+		}
+	}
+
+	// line 328 "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 < zcltok_first_final {
+		f.emitToken(TokenInvalid, p, 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 000000000..4a395c133
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/scan_tokens.rl
@@ -0,0 +1,342 @@
+package zclsyntax
+
+import (
+    "bytes"
+
+    "github.com/zclconf/go-zcl/zcl"
+)
+
+// This file is generated from scan_tokens.rl. DO NOT EDIT.
+%%{
+  # (except you are actually in scan_tokens.rl here, so edit away!)
+
+  machine zcltok;
+  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* "*/")
+        );
+
+        # Tabs are not valid, but we accept them in the scanner and mark them
+        # as tokens so that we can produce diagnostics advising the user to
+        # use spaces instead.
+        Tabs = 0x09+;
+
+        # Note: zclwrite assumes that only ASCII spaces appear between tokens,
+        # and uses this assumption to recreate the spaces between tokens by
+        # looking at byte offset differences.
+        Spaces = ' '+;
+
+        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) {
+                    token(TokenCHeredoc);
+                    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 = (
+            ('$' ^'{') |
+            ('%' ^'{') |
+            ('\\' StringLiteralChars) |
+            (StringLiteralChars - ("$" | '%' | '"'))
+        )+;
+        HeredocStringLiteral = (
+            ('$' ^'{') |
+            ('%' ^'{') |
+            (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); };
+        *|;
+
+        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;
+
+            Tabs             => { token(TokenTabs) };
+            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 = zcltok_en_main
+    case scanTemplate:
+        cs = zcltok_en_bareTemplate
+    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 < zcltok_first_final {
+        f.emitToken(TokenInvalid, p, 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 000000000..faf279170
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/spec.md
@@ -0,0 +1,879 @@
+# 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)* "{" 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 optional block _labels_. Blocks create a structural heirachy
+which can be interpreted by the calling application.
+
+## 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.
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 000000000..eb686d5de
--- /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 zcl 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 000000000..00d6d720a
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/hclsyntax/token.go
@@ -0,0 +1,271 @@
+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
+)
+
+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' {
+			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 000000000..dfe69b21a
--- /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 "fmt"
+
+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 fmt.Sprintf("TokenType(%d)", i)
+}
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 000000000..422e4e5cc
--- /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 000000000..612ad6229
--- /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 000000000..eeee1a529
--- /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 000000000..3405d268a
--- /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 000000000..8b288f938
--- /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      map[string]*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 000000000..fbdd8bff5
--- /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 000000000..4943f9bef
--- /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 000000000..d28e6037e
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/navigation.go
@@ -0,0 +1,41 @@
+package json
+
+import (
+	"strings"
+)
+
+type navigation struct {
+	root *objectVal
+}
+
+// Implementation of zcled.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]
+	}
+
+	return strings.Join(steps, ".")
+}
+
+func navigationStepsRev(obj *objectVal, offset int) []string {
+	// Do any of our properties have an object that contains the target
+	// offset?
+	for k, attr := range obj.Attrs {
+		ov, ok := attr.Value.(*objectVal)
+		if !ok {
+			continue
+		}
+
+		if ov.SrcRange.ContainsOffset(offset) {
+			return append(navigationStepsRev(ov, offset), k)
+		}
+	}
+	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 000000000..41d05fb4c
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/parser.go
@@ -0,0 +1,504 @@
+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 := map[string]*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 zcl 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
+		}
+
+		if existing := attrs[key]; existing != nil {
+			// Generate a diagnostic for the duplicate key, but continue parsing
+			// anyway since this is a semantic error we can recover from.
+			diags = diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Duplicate JSON object property",
+				Detail: fmt.Sprintf(
+					"An property named %q was previously introduced at %s",
+					key, existing.NameRange.String(),
+				),
+				Subject: &keyStrNode.SrcRange,
+			})
+		}
+		attrs[key] = &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.Float{}).Parse(string(num), 10)
+	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 000000000..fc7bbf582
--- /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 000000000..8d4b05262
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/public.go
@@ -0,0 +1,115 @@
+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 zcl configuration represented by it.
+//
+// This is not a generic JSON parser. Instead, it deals only with the profile
+// of JSON used to express zcl 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)
+	if _, ok := rootNode.(*objectVal); !ok {
+		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 a JSON object.",
+			Subject:  rootNode.StartRange().Ptr(),
+		})
+		// Put in a placeholder objectVal just so the caller always gets
+		// a valid file, even if it appears empty. This is useful for callers
+		// that are doing static analysis of possibly-erroneous source code,
+		// which will try to process the returned file even if we return
+		// diagnostics of severity error. This way, they'll get a file that
+		// has an empty body rather than a body that panics when probed.
+		fakePos := hcl.Pos{
+			Byte:   0,
+			Line:   1,
+			Column: 1,
+		}
+		fakeRange := hcl.Range{
+			Filename: filename,
+			Start:    fakePos,
+			End:      fakePos,
+		}
+		rootNode = &objectVal{
+			Attrs:     map[string]*objectAttr{},
+			SrcRange:  fakeRange,
+			OpenRange: fakeRange,
+		}
+	}
+	file := &hcl.File{
+		Body: &body{
+			obj: rootNode.(*objectVal),
+		},
+		Bytes: src,
+		Nav:   navigation{rootNode.(*objectVal)},
+	}
+	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)
+}
+
+// ParseWithHIL is like Parse except the returned file will use the HIL
+// template syntax for expressions in strings, rather than the native zcl
+// template syntax.
+//
+// This is intended for providing backward compatibility for applications that
+// used to use HCL/HIL and thus had a JSON-based format with HIL
+// interpolations.
+func ParseWithHIL(src []byte, filename string) (*hcl.File, hcl.Diagnostics) {
+	file, diags := Parse(src, filename)
+	if file != nil && file.Body != nil {
+		file.Body.(*body).useHIL = true
+	}
+	return file, diags
+}
+
+// ParseFileWithHIL is like ParseWithHIL but it reads data from a file before
+// parsing it.
+func ParseFileWithHIL(filename string) (*hcl.File, hcl.Diagnostics) {
+	file, diags := ParseFile(filename)
+	if file != nil && file.Body != nil {
+		file.Body.(*body).useHIL = true
+	}
+	return file, diags
+}
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 000000000..0a8378b9c
--- /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 000000000..d6e8bf696
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/spec.md
@@ -0,0 +1,265 @@
+# 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](../zclsyntax/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, though adaptations are defined to allow processing
+with an off-the-shelf JSON parser with certain caveats, described in later
+sections.
+
+## Structural Elements
+
+The HCL language-agnostic information model defines a _body_ as an abstract
+container for attribute definitions and child blocks. A body is represented
+in JSON as a JSON _object_.
+
+As defined in the language-agnostic model, body processing is done 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, the object
+property with the matching name — if present — 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
+object is required for each labelling level, with the object keys serving as
+the label values at that 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 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"
+        }
+      ]
+    }
+  }
+}
+```
+
+Where multiple definitions are included for the same type and labels, the
+JSON array is always the value of the property representing the final label,
+and contains objects representing block bodies. It is not valid to use an array
+at any other point in the block definition structure.
+
+## 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 object type is constructed by enumerating the JSON object properties,
+creating for each an attribute whose name exactly matches the property name,
+and whose type is the result of recursively applying the expression mapping
+rules.
+
+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.
+
+It is an error to define the same property name multiple times within a single
+JSON object interpreted as an expression.
+
+### 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 an ideal implementation
+of this specification will translate exactly the value given to a number of
+corresponding precision.
+
+In practice, off-the-shelf JSON parsers often do not support customizing the
+processing of numbers, and instead force processing as 32-bit or 64-bit
+floating point values with a potential loss of precision. It is permissable
+for a HCL JSON parser to pass on such limitations _if and only if_ the
+available precision and other constraints are defined in its documentation.
+Calling applications each have differing precision requirements, so calling
+applications are free to select an implementation with more limited precision
+capabilities should high precision not be required for that application.
+
+### 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 }"
+```
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 000000000..d13607eed
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/json/structure.go
@@ -0,0 +1,355 @@
+package json
+
+import (
+	"fmt"
+
+	"github.com/hashicorp/hcl2/hcl/hclsyntax"
+	"github.com/hashicorp/hcl2/hcl"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// body is the implementation of "Body" used for files processed with the JSON
+// parser.
+type body struct {
+	obj *objectVal
+
+	// 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{}
+
+	// If set, string values are turned into expressions using HIL's template
+	// language, rather than the native zcl language. This is intended to
+	// allow applications moving from HCL to zcl to continue to parse the
+	// JSON variant of their config that HCL handled previously.
+	useHIL bool
+}
+
+// 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)
+	}
+
+	for k, attr := range b.obj.Attrs {
+		if k == "//" {
+			// Ignore "//" keys in objects representing bodies, to allow
+			// their use as comments.
+			continue
+		}
+
+		if _, ok := hiddenAttrs[k]; !ok {
+			var fixItHint string
+			suggestion := nameSuggestion(k, nameSuggestions)
+			if suggestion != "" {
+				fixItHint = 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, fixItHint),
+				Subject:  &attr.NameRange,
+				Context:  attr.Range().Ptr(),
+			})
+		}
+	}
+
+	return content, diags
+}
+
+func (b *body) PartialContent(schema *hcl.BodySchema) (*hcl.BodyContent, hcl.Body, hcl.Diagnostics) {
+
+	obj := b.obj
+	jsonAttrs := obj.Attrs
+	usedNames := map[string]struct{}{}
+	if b.hiddenAttrs != nil {
+		for k := range b.hiddenAttrs {
+			usedNames[k] = struct{}{}
+		}
+	}
+	var diags hcl.Diagnostics
+
+	content := &hcl.BodyContent{
+		Attributes: map[string]*hcl.Attribute{},
+		Blocks:     nil,
+
+		MissingItemRange: b.MissingItemRange(),
+	}
+
+	for _, attrS := range schema.Attributes {
+		jsonAttr, exists := jsonAttrs[attrS.Name]
+		_, used := usedNames[attrS.Name]
+		if used || !exists {
+			if attrS.Required {
+				diags = diags.Append(&hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Missing required attribute",
+					Detail:   fmt.Sprintf("The attribute %q is required, so a JSON object property must be present with this name.", attrS.Name),
+					Subject:  &obj.OpenRange,
+				})
+			}
+			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[attrS.Name] = struct{}{}
+	}
+
+	for _, blockS := range schema.Blocks {
+		jsonAttr, exists := jsonAttrs[blockS.Type]
+		_, used := usedNames[blockS.Type]
+		if used || !exists {
+			usedNames[blockS.Type] = struct{}{}
+			continue
+		}
+		v := jsonAttr.Value
+		diags = append(diags, b.unpackBlock(v, blockS.Type, &jsonAttr.NameRange, blockS.LabelNames, nil, nil, &content.Blocks)...)
+		usedNames[blockS.Type] = struct{}{}
+	}
+
+	unusedBody := &body{
+		obj:         b.obj,
+		hiddenAttrs: usedNames,
+		useHIL:      b.useHIL,
+	}
+
+	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) {
+	attrs := make(map[string]*hcl.Attribute)
+	for name, jsonAttr := range b.obj.Attrs {
+		if name == "//" {
+			// Ignore "//" keys in objects representing bodies, to allow
+			// their use as comments.
+			continue
+		}
+
+		if _, hidden := b.hiddenAttrs[name]; hidden {
+			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, nil
+}
+
+func (b *body) MissingItemRange() hcl.Range {
+	return b.obj.CloseRange
+}
+
+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]
+		ov, ok := v.(*objectVal)
+		if !ok {
+			diags = diags.Append(&hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  "Incorrect JSON value type",
+				Detail:   fmt.Sprintf("A JSON object is required, whose keys represent the %s block's %s.", typeName, labelName),
+				Subject:  v.StartRange().Ptr(),
+			})
+			return
+		}
+		if len(ov.Attrs) == 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 pk, p := range ov.Attrs {
+			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{
+				obj:    tv,
+				useHIL: b.useHIL,
+			},
+
+			DefRange:    tv.OpenRange,
+			TypeRange:   *typeRange,
+			LabelRanges: labelR,
+		})
+	case *arrayVal:
+		// Multiple instances of the block
+		for _, av := range tv.Values {
+			ov, ok := av.(*objectVal)
+			if !ok {
+				diags = diags.Append(&hcl.Diagnostic{
+					Severity: hcl.DiagError,
+					Summary:  "Incorrect JSON value type",
+					Detail:   fmt.Sprintf("A JSON object is required, representing the contents of a %q block.", typeName),
+					Subject:  v.StartRange().Ptr(),
+				})
+				continue
+			}
+
+			*blocks = append(*blocks, &hcl.Block{
+				Type:   typeName,
+				Labels: labels,
+				Body: &body{
+					obj:    ov,
+					useHIL: b.useHIL,
+				},
+
+				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
+}
+
+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 zcl 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 zclsyntax 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
+		}
+
+		// FIXME: Once the native zcl template language parser is implemented,
+		// parse string values as templates and evaluate them.
+		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:
+		attrs := map[string]cty.Value{}
+		for name, jsonAttr := range v.Attrs {
+			val, _ := (&expression{src: jsonAttr.Value}).Value(ctx)
+			attrs[name] = val
+		}
+		return cty.ObjectVal(attrs), nil
+	default:
+		// Default to DynamicVal so that ASTs containing invalid nodes can
+		// still be partially-evaluated.
+		return cty.DynamicVal, nil
+	}
+}
+
+func (e *expression) Variables() []hcl.Traversal {
+	var vars []hcl.Traversal
+
+	switch v := e.src.(type) {
+	case *stringVal:
+		// FIXME: Once the native zcl template language parser is implemented,
+		// parse with that and look for variables in there too,
+
+	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()
+}
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 000000000..8773235fe
--- /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 "fmt"
+
+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 fmt.Sprintf("tokenType(%d)", i)
+}
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 000000000..ca2b728af
--- /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 000000000..80312b010
--- /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 zcl 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 000000000..3ccdfacb8
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/pos.go
@@ -0,0 +1,96 @@
+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,
+	}
+}
+
+// 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,
+		)
+	}
+}
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 000000000..891257acb
--- /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 000000000..db4e9ef97
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/spec.md
@@ -0,0 +1,646 @@
+# 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](./zclsyntax/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](./zclsyntax/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.
+
+## 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.
+
+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 000000000..98ada87b6
--- /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 000000000..b336f300d
--- /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 000000000..867ed425f
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcl/traversal.go
@@ -0,0 +1,324 @@
+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
+}
+
+// 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)
+	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")
+}
+
+// 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,
+			},
+		}
+	}
+}
+
+// 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)
+}
+
+// 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")
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcldec/block_labels.go b/vendor/github.com/hashicorp/hcl2/hcldec/block_labels.go
new file mode 100644
index 000000000..7e652e9bc
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcldec/block_labels.go
@@ -0,0 +1,21 @@
+package hcldec
+
+import (
+	"github.com/hashicorp/hcl2/hcl"
+)
+
+type blockLabel struct {
+	Value string
+	Range hcl.Range
+}
+
+func labelsForBlock(block *hcl.Block) []blockLabel {
+	ret := make([]blockLabel, len(block.Labels))
+	for i := range block.Labels {
+		ret[i] = blockLabel{
+			Value: block.Labels[i],
+			Range: block.LabelRanges[i],
+		}
+	}
+	return ret
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcldec/decode.go b/vendor/github.com/hashicorp/hcl2/hcldec/decode.go
new file mode 100644
index 000000000..6cf93fedd
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcldec/decode.go
@@ -0,0 +1,36 @@
+package hcldec
+
+import (
+	"github.com/hashicorp/hcl2/hcl"
+	"github.com/zclconf/go-cty/cty"
+)
+
+func decode(body hcl.Body, blockLabels []blockLabel, ctx *hcl.EvalContext, spec Spec, partial bool) (cty.Value, hcl.Body, hcl.Diagnostics) {
+	schema := ImpliedSchema(spec)
+
+	var content *hcl.BodyContent
+	var diags hcl.Diagnostics
+	var leftovers hcl.Body
+
+	if partial {
+		content, leftovers, diags = body.PartialContent(schema)
+	} else {
+		content, diags = body.Content(schema)
+	}
+
+	val, valDiags := spec.decode(content, blockLabels, ctx)
+	diags = append(diags, valDiags...)
+
+	return val, leftovers, diags
+}
+
+func impliedType(spec Spec) cty.Type {
+	return spec.impliedType()
+}
+
+func sourceRange(body hcl.Body, blockLabels []blockLabel, spec Spec) hcl.Range {
+	schema := ImpliedSchema(spec)
+	content, _, _ := body.PartialContent(schema)
+
+	return spec.sourceRange(content, blockLabels)
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcldec/doc.go b/vendor/github.com/hashicorp/hcl2/hcldec/doc.go
new file mode 100644
index 000000000..23bfe542b
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcldec/doc.go
@@ -0,0 +1,12 @@
+// Package hcldec provides a higher-level API for unpacking the content of
+// HCL bodies, implemented in terms of the low-level "Content" API exposed
+// by the bodies themselves.
+//
+// It allows decoding an entire nested configuration in a single operation
+// by providing a description of the intended structure.
+//
+// For some applications it may be more convenient to use the "gohcl"
+// package, which has a similar purpose but decodes directly into native
+// Go data types. hcldec instead targets the cty type system, and thus allows
+// a cty-driven application to remain within that type system.
+package hcldec
diff --git a/vendor/github.com/hashicorp/hcl2/hcldec/gob.go b/vendor/github.com/hashicorp/hcl2/hcldec/gob.go
new file mode 100644
index 000000000..e2027cfd2
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcldec/gob.go
@@ -0,0 +1,23 @@
+package hcldec
+
+import (
+	"encoding/gob"
+)
+
+func init() {
+	// Every Spec implementation should be registered with gob, so that
+	// specs can be sent over gob channels, such as using
+	// github.com/hashicorp/go-plugin with plugins that need to describe
+	// what shape of configuration they are expecting.
+	gob.Register(ObjectSpec(nil))
+	gob.Register(TupleSpec(nil))
+	gob.Register((*AttrSpec)(nil))
+	gob.Register((*LiteralSpec)(nil))
+	gob.Register((*ExprSpec)(nil))
+	gob.Register((*BlockSpec)(nil))
+	gob.Register((*BlockListSpec)(nil))
+	gob.Register((*BlockSetSpec)(nil))
+	gob.Register((*BlockMapSpec)(nil))
+	gob.Register((*BlockLabelSpec)(nil))
+	gob.Register((*DefaultSpec)(nil))
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcldec/public.go b/vendor/github.com/hashicorp/hcl2/hcldec/public.go
new file mode 100644
index 000000000..3e58f7b3c
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcldec/public.go
@@ -0,0 +1,53 @@
+package hcldec
+
+import (
+	"github.com/hashicorp/hcl2/hcl"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// Decode interprets the given body using the given specification and returns
+// the resulting value. If the given body is not valid per the spec, error
+// diagnostics are returned and the returned value is likely to be incomplete.
+//
+// The ctx argument may be nil, in which case any references to variables or
+// functions will produce error diagnostics.
+func Decode(body hcl.Body, spec Spec, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	val, _, diags := decode(body, nil, ctx, spec, false)
+	return val, diags
+}
+
+// PartialDecode is like Decode except that it permits "leftover" items in
+// the top-level body, which are returned as a new body to allow for
+// further processing.
+//
+// Any descendent block bodies are _not_ decoded partially and thus must
+// be fully described by the given specification.
+func PartialDecode(body hcl.Body, spec Spec, ctx *hcl.EvalContext) (cty.Value, hcl.Body, hcl.Diagnostics) {
+	return decode(body, nil, ctx, spec, true)
+}
+
+// ImpliedType returns the value type that should result from decoding the
+// given spec.
+func ImpliedType(spec Spec) cty.Type {
+	return impliedType(spec)
+}
+
+// SourceRange interprets the given body using the given specification and
+// then returns the source range of the value that would be used to
+// fulfill the spec.
+//
+// This can be used if application-level validation detects value errors, to
+// obtain a reasonable SourceRange to use for generated diagnostics. It works
+// best when applied to specific body items (e.g. using AttrSpec, BlockSpec, ...)
+// as opposed to entire bodies using ObjectSpec, TupleSpec. The result will
+// be less useful the broader the specification, so e.g. a spec that returns
+// the entirety of all of the blocks of a given type is likely to be
+// _particularly_ arbitrary and useless.
+//
+// If the given body is not valid per the given spec, the result is best-effort
+// and may not actually be something ideal. It's expected that an application
+// will already have used Decode or PartialDecode earlier and thus had an
+// opportunity to detect and report spec violations.
+func SourceRange(body hcl.Body, spec Spec) hcl.Range {
+	return sourceRange(body, nil, spec)
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcldec/schema.go b/vendor/github.com/hashicorp/hcl2/hcldec/schema.go
new file mode 100644
index 000000000..b57bd9692
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcldec/schema.go
@@ -0,0 +1,36 @@
+package hcldec
+
+import (
+	"github.com/hashicorp/hcl2/hcl"
+)
+
+// ImpliedSchema returns the *hcl.BodySchema implied by the given specification.
+// This is the schema that the Decode function will use internally to
+// access the content of a given body.
+func ImpliedSchema(spec Spec) *hcl.BodySchema {
+	var attrs []hcl.AttributeSchema
+	var blocks []hcl.BlockHeaderSchema
+
+	// visitSameBodyChildren walks through the spec structure, calling
+	// the given callback for each descendent spec encountered. We are
+	// interested in the specs that reference attributes and blocks.
+	var visit visitFunc
+	visit = func(s Spec) {
+		if as, ok := s.(attrSpec); ok {
+			attrs = append(attrs, as.attrSchemata()...)
+		}
+
+		if bs, ok := s.(blockSpec); ok {
+			blocks = append(blocks, bs.blockHeaderSchemata()...)
+		}
+
+		s.visitSameBodyChildren(visit)
+	}
+
+	visit(spec)
+
+	return &hcl.BodySchema{
+		Attributes: attrs,
+		Blocks:     blocks,
+	}
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcldec/spec.go b/vendor/github.com/hashicorp/hcl2/hcldec/spec.go
new file mode 100644
index 000000000..f0e6842be
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcldec/spec.go
@@ -0,0 +1,859 @@
+package hcldec
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/hashicorp/hcl2/hcl"
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+)
+
+// A Spec is a description of how to decode a hcl.Body to a cty.Value.
+//
+// The various other types in this package whose names end in "Spec" are
+// the spec implementations. The most common top-level spec is ObjectSpec,
+// which decodes body content into a cty.Value of an object type.
+type Spec interface {
+	// Perform the decode operation on the given body, in the context of
+	// the given block (which might be null), using the given eval context.
+	//
+	// "block" is provided only by the nested calls performed by the spec
+	// types that work on block bodies.
+	decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics)
+
+	// Return the cty.Type that should be returned when decoding a body with
+	// this spec.
+	impliedType() cty.Type
+
+	// Call the given callback once for each of the nested specs that would
+	// get decoded with the same body and block as the receiver. This should
+	// not descend into the nested specs used when decoding blocks.
+	visitSameBodyChildren(cb visitFunc)
+
+	// Determine the source range of the value that would be returned for the
+	// spec in the given content, in the context of the given block
+	// (which might be null). If the corresponding item is missing, return
+	// a place where it might be inserted.
+	sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range
+}
+
+type visitFunc func(spec Spec)
+
+// An ObjectSpec is a Spec that produces a cty.Value of an object type whose
+// attributes correspond to the keys of the spec map.
+type ObjectSpec map[string]Spec
+
+// attrSpec is implemented by specs that require attributes from the body.
+type attrSpec interface {
+	attrSchemata() []hcl.AttributeSchema
+}
+
+// blockSpec is implemented by specs that require blocks from the body.
+type blockSpec interface {
+	blockHeaderSchemata() []hcl.BlockHeaderSchema
+}
+
+// specNeedingVariables is implemented by specs that can use variables
+// from the EvalContext, to declare which variables they need.
+type specNeedingVariables interface {
+	variablesNeeded(content *hcl.BodyContent) []hcl.Traversal
+}
+
+func (s ObjectSpec) visitSameBodyChildren(cb visitFunc) {
+	for _, c := range s {
+		cb(c)
+	}
+}
+
+func (s ObjectSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	vals := make(map[string]cty.Value, len(s))
+	var diags hcl.Diagnostics
+
+	for k, spec := range s {
+		var kd hcl.Diagnostics
+		vals[k], kd = spec.decode(content, blockLabels, ctx)
+		diags = append(diags, kd...)
+	}
+
+	return cty.ObjectVal(vals), diags
+}
+
+func (s ObjectSpec) impliedType() cty.Type {
+	if len(s) == 0 {
+		return cty.EmptyObject
+	}
+
+	attrTypes := make(map[string]cty.Type)
+	for k, childSpec := range s {
+		attrTypes[k] = childSpec.impliedType()
+	}
+	return cty.Object(attrTypes)
+}
+
+func (s ObjectSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// This is not great, but the best we can do. In practice, it's rather
+	// strange to ask for the source range of an entire top-level body, since
+	// that's already readily available to the caller.
+	return content.MissingItemRange
+}
+
+// A TupleSpec is a Spec that produces a cty.Value of a tuple type whose
+// elements correspond to the elements of the spec slice.
+type TupleSpec []Spec
+
+func (s TupleSpec) visitSameBodyChildren(cb visitFunc) {
+	for _, c := range s {
+		cb(c)
+	}
+}
+
+func (s TupleSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	vals := make([]cty.Value, len(s))
+	var diags hcl.Diagnostics
+
+	for i, spec := range s {
+		var ed hcl.Diagnostics
+		vals[i], ed = spec.decode(content, blockLabels, ctx)
+		diags = append(diags, ed...)
+	}
+
+	return cty.TupleVal(vals), diags
+}
+
+func (s TupleSpec) impliedType() cty.Type {
+	if len(s) == 0 {
+		return cty.EmptyTuple
+	}
+
+	attrTypes := make([]cty.Type, len(s))
+	for i, childSpec := range s {
+		attrTypes[i] = childSpec.impliedType()
+	}
+	return cty.Tuple(attrTypes)
+}
+
+func (s TupleSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// This is not great, but the best we can do. In practice, it's rather
+	// strange to ask for the source range of an entire top-level body, since
+	// that's already readily available to the caller.
+	return content.MissingItemRange
+}
+
+// An AttrSpec is a Spec that evaluates a particular attribute expression in
+// the body and returns its resulting value converted to the requested type,
+// or produces a diagnostic if the type is incorrect.
+type AttrSpec struct {
+	Name     string
+	Type     cty.Type
+	Required bool
+}
+
+func (s *AttrSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node
+}
+
+// specNeedingVariables implementation
+func (s *AttrSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	attr, exists := content.Attributes[s.Name]
+	if !exists {
+		return nil
+	}
+
+	return attr.Expr.Variables()
+}
+
+// attrSpec implementation
+func (s *AttrSpec) attrSchemata() []hcl.AttributeSchema {
+	return []hcl.AttributeSchema{
+		{
+			Name:     s.Name,
+			Required: s.Required,
+		},
+	}
+}
+
+func (s *AttrSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	attr, exists := content.Attributes[s.Name]
+	if !exists {
+		return content.MissingItemRange
+	}
+
+	return attr.Expr.Range()
+}
+
+func (s *AttrSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	attr, exists := content.Attributes[s.Name]
+	if !exists {
+		// We don't need to check required and emit a diagnostic here, because
+		// that would already have happened when building "content".
+		return cty.NullVal(s.Type), nil
+	}
+
+	val, diags := attr.Expr.Value(ctx)
+
+	convVal, err := convert.Convert(val, s.Type)
+	if err != nil {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  "Incorrect attribute value type",
+			Detail: fmt.Sprintf(
+				"Inappropriate value for attribute %q: %s.",
+				s.Name, err.Error(),
+			),
+			Subject: attr.Expr.StartRange().Ptr(),
+			Context: hcl.RangeBetween(attr.NameRange, attr.Expr.StartRange()).Ptr(),
+		})
+		// We'll return an unknown value of the _correct_ type so that the
+		// incomplete result can still be used for some analysis use-cases.
+		val = cty.UnknownVal(s.Type)
+	} else {
+		val = convVal
+	}
+
+	return val, diags
+}
+
+func (s *AttrSpec) impliedType() cty.Type {
+	return s.Type
+}
+
+// A LiteralSpec is a Spec that produces the given literal value, ignoring
+// the given body.
+type LiteralSpec struct {
+	Value cty.Value
+}
+
+func (s *LiteralSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node
+}
+
+func (s *LiteralSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	return s.Value, nil
+}
+
+func (s *LiteralSpec) impliedType() cty.Type {
+	return s.Value.Type()
+}
+
+func (s *LiteralSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// No sensible range to return for a literal, so the caller had better
+	// ensure it doesn't cause any diagnostics.
+	return hcl.Range{
+		Filename: "<unknown>",
+	}
+}
+
+// An ExprSpec is a Spec that evaluates the given expression, ignoring the
+// given body.
+type ExprSpec struct {
+	Expr hcl.Expression
+}
+
+func (s *ExprSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node
+}
+
+// specNeedingVariables implementation
+func (s *ExprSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	return s.Expr.Variables()
+}
+
+func (s *ExprSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	return s.Expr.Value(ctx)
+}
+
+func (s *ExprSpec) impliedType() cty.Type {
+	// We can't know the type of our expression until we evaluate it
+	return cty.DynamicPseudoType
+}
+
+func (s *ExprSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	return s.Expr.Range()
+}
+
+// A BlockSpec is a Spec that produces a cty.Value by decoding the contents
+// of a single nested block of a given type, using a nested spec.
+//
+// If the Required flag is not set, the nested block may be omitted, in which
+// case a null value is produced. If it _is_ set, an error diagnostic is
+// produced if there are no nested blocks of the given type.
+type BlockSpec struct {
+	TypeName string
+	Nested   Spec
+	Required bool
+}
+
+func (s *BlockSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node ("Nested" does not use the same body)
+}
+
+// blockSpec implementation
+func (s *BlockSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
+	return []hcl.BlockHeaderSchema{
+		{
+			Type:       s.TypeName,
+			LabelNames: findLabelSpecs(s.Nested),
+		},
+	}
+}
+
+// specNeedingVariables implementation
+func (s *BlockSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	var childBlock *hcl.Block
+	for _, candidate := range content.Blocks {
+		if candidate.Type != s.TypeName {
+			continue
+		}
+
+		childBlock = candidate
+		break
+	}
+
+	if childBlock == nil {
+		return nil
+	}
+
+	return Variables(childBlock.Body, s.Nested)
+}
+
+func (s *BlockSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	var childBlock *hcl.Block
+	for _, candidate := range content.Blocks {
+		if candidate.Type != s.TypeName {
+			continue
+		}
+
+		if childBlock != nil {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Duplicate %s block", s.TypeName),
+				Detail: fmt.Sprintf(
+					"Only one block of type %q is allowed. Previous definition was at %s.",
+					s.TypeName, childBlock.DefRange.String(),
+				),
+				Subject: &candidate.DefRange,
+			})
+			break
+		}
+
+		childBlock = candidate
+	}
+
+	if childBlock == nil {
+		if s.Required {
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Missing %s block", s.TypeName),
+				Detail: fmt.Sprintf(
+					"A block of type %q is required here.", s.TypeName,
+				),
+				Subject: &content.MissingItemRange,
+			})
+		}
+		return cty.NullVal(s.Nested.impliedType()), diags
+	}
+
+	if s.Nested == nil {
+		panic("BlockSpec with no Nested Spec")
+	}
+	val, _, childDiags := decode(childBlock.Body, labelsForBlock(childBlock), ctx, s.Nested, false)
+	diags = append(diags, childDiags...)
+	return val, diags
+}
+
+func (s *BlockSpec) impliedType() cty.Type {
+	return s.Nested.impliedType()
+}
+
+func (s *BlockSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	var childBlock *hcl.Block
+	for _, candidate := range content.Blocks {
+		if candidate.Type != s.TypeName {
+			continue
+		}
+
+		childBlock = candidate
+		break
+	}
+
+	if childBlock == nil {
+		return content.MissingItemRange
+	}
+
+	return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested)
+}
+
+// A BlockListSpec is a Spec that produces a cty list of the results of
+// decoding all of the nested blocks of a given type, using a nested spec.
+type BlockListSpec struct {
+	TypeName string
+	Nested   Spec
+	MinItems int
+	MaxItems int
+}
+
+func (s *BlockListSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node ("Nested" does not use the same body)
+}
+
+// blockSpec implementation
+func (s *BlockListSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
+	return []hcl.BlockHeaderSchema{
+		{
+			Type:       s.TypeName,
+			LabelNames: findLabelSpecs(s.Nested),
+		},
+	}
+}
+
+// specNeedingVariables implementation
+func (s *BlockListSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	var ret []hcl.Traversal
+
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		ret = append(ret, Variables(childBlock.Body, s.Nested)...)
+	}
+
+	return ret
+}
+
+func (s *BlockListSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	if s.Nested == nil {
+		panic("BlockListSpec with no Nested Spec")
+	}
+
+	var elems []cty.Value
+	var sourceRanges []hcl.Range
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		val, _, childDiags := decode(childBlock.Body, labelsForBlock(childBlock), ctx, s.Nested, false)
+		diags = append(diags, childDiags...)
+		elems = append(elems, val)
+		sourceRanges = append(sourceRanges, sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested))
+	}
+
+	if len(elems) < s.MinItems {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Insufficient %s blocks", s.TypeName),
+			Detail:   fmt.Sprintf("At least %d %q blocks are required.", s.MinItems, s.TypeName),
+			Subject:  &content.MissingItemRange,
+		})
+	} else if s.MaxItems > 0 && len(elems) > s.MaxItems {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Too many %s blocks", s.TypeName),
+			Detail:   fmt.Sprintf("No more than %d %q blocks are allowed", s.MaxItems, s.TypeName),
+			Subject:  &sourceRanges[s.MaxItems],
+		})
+	}
+
+	var ret cty.Value
+
+	if len(elems) == 0 {
+		ret = cty.ListValEmpty(s.Nested.impliedType())
+	} else {
+		ret = cty.ListVal(elems)
+	}
+
+	return ret, diags
+}
+
+func (s *BlockListSpec) impliedType() cty.Type {
+	return cty.List(s.Nested.impliedType())
+}
+
+func (s *BlockListSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// We return the source range of the _first_ block of the given type,
+	// since they are not guaranteed to form a contiguous range.
+
+	var childBlock *hcl.Block
+	for _, candidate := range content.Blocks {
+		if candidate.Type != s.TypeName {
+			continue
+		}
+
+		childBlock = candidate
+		break
+	}
+
+	if childBlock == nil {
+		return content.MissingItemRange
+	}
+
+	return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested)
+}
+
+// A BlockSetSpec is a Spec that produces a cty set of the results of
+// decoding all of the nested blocks of a given type, using a nested spec.
+type BlockSetSpec struct {
+	TypeName string
+	Nested   Spec
+	MinItems int
+	MaxItems int
+}
+
+func (s *BlockSetSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node ("Nested" does not use the same body)
+}
+
+// blockSpec implementation
+func (s *BlockSetSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
+	return []hcl.BlockHeaderSchema{
+		{
+			Type:       s.TypeName,
+			LabelNames: findLabelSpecs(s.Nested),
+		},
+	}
+}
+
+// specNeedingVariables implementation
+func (s *BlockSetSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	var ret []hcl.Traversal
+
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		ret = append(ret, Variables(childBlock.Body, s.Nested)...)
+	}
+
+	return ret
+}
+
+func (s *BlockSetSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	if s.Nested == nil {
+		panic("BlockSetSpec with no Nested Spec")
+	}
+
+	var elems []cty.Value
+	var sourceRanges []hcl.Range
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		val, _, childDiags := decode(childBlock.Body, labelsForBlock(childBlock), ctx, s.Nested, false)
+		diags = append(diags, childDiags...)
+		elems = append(elems, val)
+		sourceRanges = append(sourceRanges, sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested))
+	}
+
+	if len(elems) < s.MinItems {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Insufficient %s blocks", s.TypeName),
+			Detail:   fmt.Sprintf("At least %d %q blocks are required.", s.MinItems, s.TypeName),
+			Subject:  &content.MissingItemRange,
+		})
+	} else if s.MaxItems > 0 && len(elems) > s.MaxItems {
+		diags = append(diags, &hcl.Diagnostic{
+			Severity: hcl.DiagError,
+			Summary:  fmt.Sprintf("Too many %s blocks", s.TypeName),
+			Detail:   fmt.Sprintf("No more than %d %q blocks are allowed", s.MaxItems, s.TypeName),
+			Subject:  &sourceRanges[s.MaxItems],
+		})
+	}
+
+	var ret cty.Value
+
+	if len(elems) == 0 {
+		ret = cty.SetValEmpty(s.Nested.impliedType())
+	} else {
+		ret = cty.SetVal(elems)
+	}
+
+	return ret, diags
+}
+
+func (s *BlockSetSpec) impliedType() cty.Type {
+	return cty.Set(s.Nested.impliedType())
+}
+
+func (s *BlockSetSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// We return the source range of the _first_ block of the given type,
+	// since they are not guaranteed to form a contiguous range.
+
+	var childBlock *hcl.Block
+	for _, candidate := range content.Blocks {
+		if candidate.Type != s.TypeName {
+			continue
+		}
+
+		childBlock = candidate
+		break
+	}
+
+	if childBlock == nil {
+		return content.MissingItemRange
+	}
+
+	return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested)
+}
+
+// A BlockMapSpec is a Spec that produces a cty map of the results of
+// decoding all of the nested blocks of a given type, using a nested spec.
+//
+// One level of map structure is created for each of the given label names.
+// There must be at least one given label name.
+type BlockMapSpec struct {
+	TypeName   string
+	LabelNames []string
+	Nested     Spec
+}
+
+func (s *BlockMapSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node ("Nested" does not use the same body)
+}
+
+// blockSpec implementation
+func (s *BlockMapSpec) blockHeaderSchemata() []hcl.BlockHeaderSchema {
+	return []hcl.BlockHeaderSchema{
+		{
+			Type:       s.TypeName,
+			LabelNames: append(s.LabelNames, findLabelSpecs(s.Nested)...),
+		},
+	}
+}
+
+// specNeedingVariables implementation
+func (s *BlockMapSpec) variablesNeeded(content *hcl.BodyContent) []hcl.Traversal {
+	var ret []hcl.Traversal
+
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		ret = append(ret, Variables(childBlock.Body, s.Nested)...)
+	}
+
+	return ret
+}
+
+func (s *BlockMapSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	var diags hcl.Diagnostics
+
+	if s.Nested == nil {
+		panic("BlockSetSpec with no Nested Spec")
+	}
+
+	elems := map[string]interface{}{}
+	for _, childBlock := range content.Blocks {
+		if childBlock.Type != s.TypeName {
+			continue
+		}
+
+		childLabels := labelsForBlock(childBlock)
+		val, _, childDiags := decode(childBlock.Body, childLabels[len(s.LabelNames):], ctx, s.Nested, false)
+		targetMap := elems
+		for _, key := range childBlock.Labels[:len(s.LabelNames)-1] {
+			if _, exists := targetMap[key]; !exists {
+				targetMap[key] = make(map[string]interface{})
+			}
+			targetMap = targetMap[key].(map[string]interface{})
+		}
+
+		diags = append(diags, childDiags...)
+
+		key := childBlock.Labels[len(s.LabelNames)-1]
+		if _, exists := targetMap[key]; exists {
+			labelsBuf := bytes.Buffer{}
+			for _, label := range childBlock.Labels {
+				fmt.Fprintf(&labelsBuf, " %q", label)
+			}
+			diags = append(diags, &hcl.Diagnostic{
+				Severity: hcl.DiagError,
+				Summary:  fmt.Sprintf("Duplicate %s block", s.TypeName),
+				Detail: fmt.Sprintf(
+					"A block for %s%s was already defined. The %s labels must be unique.",
+					s.TypeName, labelsBuf.String(), s.TypeName,
+				),
+				Subject: &childBlock.DefRange,
+			})
+			continue
+		}
+
+		targetMap[key] = val
+	}
+
+	if len(elems) == 0 {
+		return cty.MapValEmpty(s.Nested.impliedType()), diags
+	}
+
+	var ctyMap func(map[string]interface{}, int) cty.Value
+	ctyMap = func(raw map[string]interface{}, depth int) cty.Value {
+		vals := make(map[string]cty.Value, len(raw))
+		if depth == 1 {
+			for k, v := range raw {
+				vals[k] = v.(cty.Value)
+			}
+		} else {
+			for k, v := range raw {
+				vals[k] = ctyMap(v.(map[string]interface{}), depth-1)
+			}
+		}
+		return cty.MapVal(vals)
+	}
+
+	return ctyMap(elems, len(s.LabelNames)), diags
+}
+
+func (s *BlockMapSpec) impliedType() cty.Type {
+	ret := s.Nested.impliedType()
+	for _ = range s.LabelNames {
+		ret = cty.Map(ret)
+	}
+	return ret
+}
+
+func (s *BlockMapSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// We return the source range of the _first_ block of the given type,
+	// since they are not guaranteed to form a contiguous range.
+
+	var childBlock *hcl.Block
+	for _, candidate := range content.Blocks {
+		if candidate.Type != s.TypeName {
+			continue
+		}
+
+		childBlock = candidate
+		break
+	}
+
+	if childBlock == nil {
+		return content.MissingItemRange
+	}
+
+	return sourceRange(childBlock.Body, labelsForBlock(childBlock), s.Nested)
+}
+
+// A BlockLabelSpec is a Spec that returns a cty.String representing the
+// label of the block its given body belongs to, if indeed its given body
+// belongs to a block. It is a programming error to use this in a non-block
+// context, so this spec will panic in that case.
+//
+// This spec only works in the nested spec within a BlockSpec, BlockListSpec,
+// BlockSetSpec or BlockMapSpec.
+//
+// The full set of label specs used against a particular block must have a
+// consecutive set of indices starting at zero. The maximum index found
+// defines how many labels the corresponding blocks must have in cty source.
+type BlockLabelSpec struct {
+	Index int
+	Name  string
+}
+
+func (s *BlockLabelSpec) visitSameBodyChildren(cb visitFunc) {
+	// leaf node
+}
+
+func (s *BlockLabelSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	if s.Index >= len(blockLabels) {
+		panic("BlockListSpec used in non-block context")
+	}
+
+	return cty.StringVal(blockLabels[s.Index].Value), nil
+}
+
+func (s *BlockLabelSpec) impliedType() cty.Type {
+	return cty.String // labels are always strings
+}
+
+func (s *BlockLabelSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	if s.Index >= len(blockLabels) {
+		panic("BlockListSpec used in non-block context")
+	}
+
+	return blockLabels[s.Index].Range
+}
+
+func findLabelSpecs(spec Spec) []string {
+	maxIdx := -1
+	var names map[int]string
+
+	var visit visitFunc
+	visit = func(s Spec) {
+		if ls, ok := s.(*BlockLabelSpec); ok {
+			if maxIdx < ls.Index {
+				maxIdx = ls.Index
+			}
+			if names == nil {
+				names = make(map[int]string)
+			}
+			names[ls.Index] = ls.Name
+		}
+		s.visitSameBodyChildren(visit)
+	}
+
+	visit(spec)
+
+	if maxIdx < 0 {
+		return nil // no labels at all
+	}
+
+	ret := make([]string, maxIdx+1)
+	for i := range ret {
+		name := names[i]
+		if name == "" {
+			// Should never happen if the spec is conformant, since we require
+			// consecutive indices starting at zero.
+			name = fmt.Sprintf("missing%02d", i)
+		}
+		ret[i] = name
+	}
+
+	return ret
+}
+
+// DefaultSpec is a spec that wraps two specs, evaluating the primary first
+// and then evaluating the default if the primary returns a null value.
+//
+// The two specifications must have the same implied result type for correct
+// operation. If not, the result is undefined.
+type DefaultSpec struct {
+	Primary Spec
+	Default Spec
+}
+
+func (s *DefaultSpec) visitSameBodyChildren(cb visitFunc) {
+	cb(s.Primary)
+	cb(s.Default)
+}
+
+func (s *DefaultSpec) decode(content *hcl.BodyContent, blockLabels []blockLabel, ctx *hcl.EvalContext) (cty.Value, hcl.Diagnostics) {
+	val, diags := s.Primary.decode(content, blockLabels, ctx)
+	if val.IsNull() {
+		var moreDiags hcl.Diagnostics
+		val, moreDiags = s.Default.decode(content, blockLabels, ctx)
+		diags = append(diags, moreDiags...)
+	}
+	return val, diags
+}
+
+func (s *DefaultSpec) impliedType() cty.Type {
+	return s.Primary.impliedType()
+}
+
+func (s *DefaultSpec) sourceRange(content *hcl.BodyContent, blockLabels []blockLabel) hcl.Range {
+	// We can't tell from here which of the two specs will ultimately be used
+	// in our result, so we'll just assume the first. This is usually the right
+	// choice because the default is often a literal spec that doesn't have a
+	// reasonable source range to return anyway.
+	return s.Primary.sourceRange(content, blockLabels)
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hcldec/variables.go b/vendor/github.com/hashicorp/hcl2/hcldec/variables.go
new file mode 100644
index 000000000..427b0d0e6
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hcldec/variables.go
@@ -0,0 +1,34 @@
+package hcldec
+
+import (
+	"github.com/hashicorp/hcl2/hcl"
+)
+
+// Variables processes the given body with the given spec and returns a
+// list of the variable traversals that would be required to decode
+// the same pairing of body and spec.
+//
+// This can be used to conditionally populate the variables in the EvalContext
+// passed to Decode, for applications where a static scope is insufficient.
+//
+// If the given body is not compliant with the given schema, the result may
+// be incomplete, but that's assumed to be okay because the eventual call
+// to Decode will produce error diagnostics anyway.
+func Variables(body hcl.Body, spec Spec) []hcl.Traversal {
+	schema := ImpliedSchema(spec)
+
+	content, _, _ := body.PartialContent(schema)
+
+	var vars []hcl.Traversal
+
+	if vs, ok := spec.(specNeedingVariables); ok {
+		vars = append(vars, vs.variablesNeeded(content)...)
+	}
+	spec.visitSameBodyChildren(func(s Spec) {
+		if vs, ok := s.(specNeedingVariables); ok {
+			vars = append(vars, vs.variablesNeeded(content)...)
+		}
+	})
+
+	return vars
+}
diff --git a/vendor/github.com/hashicorp/hcl2/hclparse/parser.go b/vendor/github.com/hashicorp/hcl2/hclparse/parser.go
new file mode 100644
index 000000000..6d47f1268
--- /dev/null
+++ b/vendor/github.com/hashicorp/hcl2/hclparse/parser.go
@@ -0,0 +1,123 @@
+package hclparse
+
+import (
+	"fmt"
+	"io/ioutil"
+
+	"github.com/hashicorp/hcl2/hcl"
+	"github.com/hashicorp/hcl2/hcl/hclsyntax"
+	"github.com/hashicorp/hcl2/hcl/json"
+)
+
+// NOTE: This is the public interface for parsing. The actual parsers are
+// in other packages alongside this one, with this package just wrapping them
+// to provide a unified interface for the caller across all supported formats.
+
+// Parser is the main interface for parsing configuration files. As well as
+// parsing files, a parser also retains a registry of all of the files it
+// has parsed so that multiple attempts to parse the same file will return
+// the same object and so the collected files can be used when printing
+// diagnostics.
+//
+// Any diagnostics for parsing a file are only returned once on the first
+// call to parse that file. Callers are expected to collect up diagnostics
+// and present them together, so returning diagnostics for the same file
+// multiple times would create a confusing result.
+type Parser struct {
+	files map[string]*hcl.File
+}
+
+// NewParser creates a new parser, ready to parse configuration files.
+func NewParser() *Parser {
+	return &Parser{
+		files: map[string]*hcl.File{},
+	}
+}
+
+// ParseHCL parses the given buffer (which is assumed to have been loaded from
+// the given filename) as a native-syntax configuration file and returns the
+// hcl.File object representing it.
+func (p *Parser) ParseHCL(src []byte, filename string) (*hcl.File, hcl.Diagnostics) {
+	if existing := p.files[filename]; existing != nil {
+		return existing, nil
+	}
+
+	file, diags := hclsyntax.ParseConfig(src, filename, hcl.Pos{Byte: 0, Line: 1, Column: 1})
+	p.files[filename] = file
+	return file, diags
+}
+
+// ParseHCLFile reads the given filename and parses it as a native-syntax HCL
+// configuration file. An error diagnostic is returned if the given file
+// cannot be read.
+func (p *Parser) ParseHCLFile(filename string) (*hcl.File, hcl.Diagnostics) {
+	if existing := p.files[filename]; existing != nil {
+		return existing, nil
+	}
+
+	src, err := ioutil.ReadFile(filename)
+	if err != nil {
+		return nil, hcl.Diagnostics{
+			{
+				Severity: hcl.DiagError,
+				Summary:  "Failed to read file",
+				Detail:   fmt.Sprintf("The configuration file %q could not be read.", filename),
+			},
+		}
+	}
+
+	return p.ParseHCL(src, filename)
+}
+
+// ParseJSON parses the given JSON buffer (which is assumed to have been loaded
+// from the given filename) and returns the hcl.File object representing it.
+func (p *Parser) ParseJSON(src []byte, filename string) (*hcl.File, hcl.Diagnostics) {
+	if existing := p.files[filename]; existing != nil {
+		return existing, nil
+	}
+
+	file, diags := json.Parse(src, filename)
+	p.files[filename] = file
+	return file, diags
+}
+
+// ParseJSONFile reads the given filename and parses it as JSON, similarly to
+// ParseJSON. An error diagnostic is returned if the given file cannot be read.
+func (p *Parser) ParseJSONFile(filename string) (*hcl.File, hcl.Diagnostics) {
+	if existing := p.files[filename]; existing != nil {
+		return existing, nil
+	}
+
+	file, diags := json.ParseFile(filename)
+	p.files[filename] = file
+	return file, diags
+}
+
+// AddFile allows a caller to record in a parser a file that was parsed some
+// other way, thus allowing it to be included in the registry of sources.
+func (p *Parser) AddFile(filename string, file *hcl.File) {
+	p.files[filename] = file
+}
+
+// Sources returns a map from filenames to the raw source code that was
+// read from them. This is intended to be used, for example, to print
+// diagnostics with contextual information.
+//
+// The arrays underlying the returned slices should not be modified.
+func (p *Parser) Sources() map[string][]byte {
+	ret := make(map[string][]byte)
+	for fn, f := range p.files {
+		ret[fn] = f.Bytes
+	}
+	return ret
+}
+
+// Files returns a map from filenames to the File objects produced from them.
+// This is intended to be used, for example, to print diagnostics with
+// contextual information.
+//
+// The returned map and all of the objects it refers to directly or indirectly
+// must not be modified.
+func (p *Parser) Files() map[string]*hcl.File {
+	return p.files
+}
diff --git a/vendor/github.com/hashicorp/terraform/backend/remote-state/azure/backend.go b/vendor/github.com/hashicorp/terraform/backend/remote-state/azure/backend.go
new file mode 100644
index 000000000..5c7577b30
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/backend/remote-state/azure/backend.go
@@ -0,0 +1,225 @@
+package azure
+
+import (
+	"context"
+	"fmt"
+
+	armStorage "github.com/Azure/azure-sdk-for-go/arm/storage"
+	"github.com/Azure/azure-sdk-for-go/storage"
+	"github.com/Azure/go-autorest/autorest"
+	"github.com/Azure/go-autorest/autorest/adal"
+	"github.com/Azure/go-autorest/autorest/azure"
+	"github.com/hashicorp/terraform/backend"
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+// New creates a new backend for S3 remote state.
+func New() backend.Backend {
+	s := &schema.Backend{
+		Schema: map[string]*schema.Schema{
+			"storage_account_name": {
+				Type:        schema.TypeString,
+				Required:    true,
+				Description: "The name of the storage account.",
+			},
+
+			"container_name": {
+				Type:        schema.TypeString,
+				Required:    true,
+				Description: "The container name.",
+			},
+
+			"key": {
+				Type:        schema.TypeString,
+				Required:    true,
+				Description: "The blob key.",
+			},
+
+			"environment": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "The Azure cloud environment.",
+				Default:     "",
+			},
+
+			"access_key": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "The access key.",
+				DefaultFunc: schema.EnvDefaultFunc("ARM_ACCESS_KEY", ""),
+			},
+
+			"resource_group_name": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "The resource group name.",
+			},
+
+			"arm_subscription_id": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "The Subscription ID.",
+				DefaultFunc: schema.EnvDefaultFunc("ARM_SUBSCRIPTION_ID", ""),
+			},
+
+			"arm_client_id": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "The Client ID.",
+				DefaultFunc: schema.EnvDefaultFunc("ARM_CLIENT_ID", ""),
+			},
+
+			"arm_client_secret": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "The Client Secret.",
+				DefaultFunc: schema.EnvDefaultFunc("ARM_CLIENT_SECRET", ""),
+			},
+
+			"arm_tenant_id": {
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "The Tenant ID.",
+				DefaultFunc: schema.EnvDefaultFunc("ARM_TENANT_ID", ""),
+			},
+		},
+	}
+
+	result := &Backend{Backend: s}
+	result.Backend.ConfigureFunc = result.configure
+	return result
+}
+
+type Backend struct {
+	*schema.Backend
+
+	// The fields below are set from configure
+	blobClient storage.BlobStorageClient
+
+	containerName string
+	keyName       string
+	leaseID       string
+}
+
+type BackendConfig struct {
+	AccessKey          string
+	Environment        string
+	ClientID           string
+	ClientSecret       string
+	ResourceGroupName  string
+	StorageAccountName string
+	SubscriptionID     string
+	TenantID           string
+}
+
+func (b *Backend) configure(ctx context.Context) error {
+	if b.containerName != "" {
+		return nil
+	}
+
+	// Grab the resource data
+	data := schema.FromContextBackendConfig(ctx)
+
+	b.containerName = data.Get("container_name").(string)
+	b.keyName = data.Get("key").(string)
+
+	config := BackendConfig{
+		AccessKey:          data.Get("access_key").(string),
+		ClientID:           data.Get("arm_client_id").(string),
+		ClientSecret:       data.Get("arm_client_secret").(string),
+		Environment:        data.Get("environment").(string),
+		ResourceGroupName:  data.Get("resource_group_name").(string),
+		StorageAccountName: data.Get("storage_account_name").(string),
+		SubscriptionID:     data.Get("arm_subscription_id").(string),
+		TenantID:           data.Get("arm_tenant_id").(string),
+	}
+
+	blobClient, err := getBlobClient(config)
+	if err != nil {
+		return err
+	}
+	b.blobClient = blobClient
+
+	return nil
+}
+
+func getBlobClient(config BackendConfig) (storage.BlobStorageClient, error) {
+	var client storage.BlobStorageClient
+
+	env, err := getAzureEnvironment(config.Environment)
+	if err != nil {
+		return client, err
+	}
+
+	accessKey, err := getAccessKey(config, env)
+	if err != nil {
+		return client, err
+	}
+
+	storageClient, err := storage.NewClient(config.StorageAccountName, accessKey, env.StorageEndpointSuffix,
+		storage.DefaultAPIVersion, true)
+	if err != nil {
+		return client, fmt.Errorf("Error creating storage client for storage account %q: %s", config.StorageAccountName, err)
+	}
+
+	client = storageClient.GetBlobService()
+	return client, nil
+}
+
+func getAccessKey(config BackendConfig, env azure.Environment) (string, error) {
+	if config.AccessKey != "" {
+		return config.AccessKey, nil
+	}
+
+	rgOk := config.ResourceGroupName != ""
+	subOk := config.SubscriptionID != ""
+	clientIDOk := config.ClientID != ""
+	clientSecretOK := config.ClientSecret != ""
+	tenantIDOk := config.TenantID != ""
+	if !rgOk || !subOk || !clientIDOk || !clientSecretOK || !tenantIDOk {
+		return "", fmt.Errorf("resource_group_name and credentials must be provided when access_key is absent")
+	}
+
+	oauthConfig, err := adal.NewOAuthConfig(env.ActiveDirectoryEndpoint, config.TenantID)
+	if err != nil {
+		return "", err
+	}
+
+	spt, err := adal.NewServicePrincipalToken(*oauthConfig, config.ClientID, config.ClientSecret, env.ResourceManagerEndpoint)
+	if err != nil {
+		return "", err
+	}
+
+	accountsClient := armStorage.NewAccountsClientWithBaseURI(env.ResourceManagerEndpoint, config.SubscriptionID)
+	accountsClient.Authorizer = autorest.NewBearerAuthorizer(spt)
+
+	keys, err := accountsClient.ListKeys(config.ResourceGroupName, config.StorageAccountName)
+	if err != nil {
+		return "", fmt.Errorf("Error retrieving keys for storage account %q: %s", config.StorageAccountName, err)
+	}
+
+	if keys.Keys == nil {
+		return "", fmt.Errorf("Nil key returned for storage account %q", config.StorageAccountName)
+	}
+
+	accessKeys := *keys.Keys
+	return *accessKeys[0].Value, nil
+}
+
+func getAzureEnvironment(environment string) (azure.Environment, error) {
+	if environment == "" {
+		return azure.PublicCloud, nil
+	}
+
+	env, err := azure.EnvironmentFromName(environment)
+	if err != nil {
+		// try again with wrapped value to support readable values like german instead of AZUREGERMANCLOUD
+		var innerErr error
+		env, innerErr = azure.EnvironmentFromName(fmt.Sprintf("AZURE%sCLOUD", environment))
+		if innerErr != nil {
+			return env, fmt.Errorf("invalid 'environment' configuration: %s", err)
+		}
+	}
+
+	return env, nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/backend/remote-state/azure/backend_state.go b/vendor/github.com/hashicorp/terraform/backend/remote-state/azure/backend_state.go
new file mode 100644
index 000000000..c7bc02755
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/backend/remote-state/azure/backend_state.go
@@ -0,0 +1,141 @@
+package azure
+
+import (
+	"fmt"
+	"sort"
+	"strings"
+
+	"github.com/Azure/azure-sdk-for-go/storage"
+	"github.com/hashicorp/terraform/backend"
+	"github.com/hashicorp/terraform/state"
+	"github.com/hashicorp/terraform/state/remote"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+const (
+	// This will be used as directory name, the odd looking colon is simply to
+	// reduce the chance of name conflicts with existing objects.
+	keyEnvPrefix = "env:"
+)
+
+func (b *Backend) States() ([]string, error) {
+	prefix := b.keyName + keyEnvPrefix
+	params := storage.ListBlobsParameters{
+		Prefix: prefix,
+	}
+
+	container := b.blobClient.GetContainerReference(b.containerName)
+	resp, err := container.ListBlobs(params)
+	if err != nil {
+		return nil, err
+	}
+
+	envs := map[string]struct{}{}
+	for _, obj := range resp.Blobs {
+		key := obj.Name
+		if strings.HasPrefix(key, prefix) {
+			name := strings.TrimPrefix(key, prefix)
+			// we store the state in a key, not a directory
+			if strings.Contains(name, "/") {
+				continue
+			}
+
+			envs[name] = struct{}{}
+		}
+	}
+
+	result := []string{backend.DefaultStateName}
+	for name := range envs {
+		result = append(result, name)
+	}
+	sort.Strings(result[1:])
+	return result, nil
+}
+
+func (b *Backend) DeleteState(name string) error {
+	if name == backend.DefaultStateName || name == "" {
+		return fmt.Errorf("can't delete default state")
+	}
+
+	containerReference := b.blobClient.GetContainerReference(b.containerName)
+	blobReference := containerReference.GetBlobReference(b.path(name))
+	options := &storage.DeleteBlobOptions{}
+
+	return blobReference.Delete(options)
+}
+
+func (b *Backend) State(name string) (state.State, error) {
+	client := &RemoteClient{
+		blobClient:    b.blobClient,
+		containerName: b.containerName,
+		keyName:       b.path(name),
+	}
+
+	stateMgr := &remote.State{Client: client}
+
+	//if this isn't the default state name, we need to create the object so
+	//it's listed by States.
+	if name != backend.DefaultStateName {
+		// take a lock on this state while we write it
+		lockInfo := state.NewLockInfo()
+		lockInfo.Operation = "init"
+		lockId, err := client.Lock(lockInfo)
+		if err != nil {
+			return nil, fmt.Errorf("failed to lock azure state: %s", err)
+		}
+
+		// Local helper function so we can call it multiple places
+		lockUnlock := func(parent error) error {
+			if err := stateMgr.Unlock(lockId); err != nil {
+				return fmt.Errorf(strings.TrimSpace(errStateUnlock), lockId, err)
+			}
+			return parent
+		}
+
+		// Grab the value
+		if err := stateMgr.RefreshState(); err != nil {
+			err = lockUnlock(err)
+			return nil, err
+		}
+
+		// If we have no state, we have to create an empty state
+		if v := stateMgr.State(); v == nil {
+			if err := stateMgr.WriteState(terraform.NewState()); err != nil {
+				err = lockUnlock(err)
+				return nil, err
+			}
+			if err := stateMgr.PersistState(); err != nil {
+				err = lockUnlock(err)
+				return nil, err
+			}
+		}
+
+		// Unlock, the state should now be initialized
+		if err := lockUnlock(nil); err != nil {
+			return nil, err
+		}
+
+	}
+
+	return stateMgr, nil
+}
+
+func (b *Backend) client() *RemoteClient {
+	return &RemoteClient{}
+}
+
+func (b *Backend) path(name string) string {
+	if name == backend.DefaultStateName {
+		return b.keyName
+	}
+
+	return b.keyName + keyEnvPrefix + name
+}
+
+const errStateUnlock = `
+Error unlocking Azure state. Lock ID: %s
+
+Error: %s
+
+You may have to force-unlock this state in order to use it again.
+`
diff --git a/vendor/github.com/hashicorp/terraform/backend/remote-state/azure/client.go b/vendor/github.com/hashicorp/terraform/backend/remote-state/azure/client.go
new file mode 100644
index 000000000..52999579b
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/backend/remote-state/azure/client.go
@@ -0,0 +1,271 @@
+package azure
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"io"
+	"log"
+
+	"encoding/base64"
+	"github.com/Azure/azure-sdk-for-go/storage"
+	multierror "github.com/hashicorp/go-multierror"
+	uuid "github.com/hashicorp/go-uuid"
+	"github.com/hashicorp/terraform/state"
+	"github.com/hashicorp/terraform/state/remote"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+const (
+	leaseHeader = "x-ms-lease-id"
+	// Must be lower case
+	lockInfoMetaKey = "terraformlockid"
+)
+
+type RemoteClient struct {
+	blobClient    storage.BlobStorageClient
+	containerName string
+	keyName       string
+	leaseID       string
+}
+
+func (c *RemoteClient) Get() (*remote.Payload, error) {
+	containerReference := c.blobClient.GetContainerReference(c.containerName)
+	blobReference := containerReference.GetBlobReference(c.keyName)
+	options := &storage.GetBlobOptions{}
+
+	if c.leaseID != "" {
+		options.LeaseID = c.leaseID
+	}
+
+	blob, err := blobReference.Get(options)
+	if err != nil {
+		if storErr, ok := err.(storage.AzureStorageServiceError); ok {
+			if storErr.Code == "BlobNotFound" {
+				return nil, nil
+			}
+		}
+		return nil, err
+	}
+
+	defer blob.Close()
+
+	buf := bytes.NewBuffer(nil)
+	if _, err := io.Copy(buf, blob); err != nil {
+		return nil, fmt.Errorf("Failed to read remote state: %s", err)
+	}
+
+	payload := &remote.Payload{
+		Data: buf.Bytes(),
+	}
+
+	// If there was no data, then return nil
+	if len(payload.Data) == 0 {
+		return nil, nil
+	}
+
+	return payload, nil
+}
+
+func (c *RemoteClient) Put(data []byte) error {
+	getOptions := &storage.GetBlobMetadataOptions{}
+	setOptions := &storage.SetBlobPropertiesOptions{}
+	putOptions := &storage.PutBlobOptions{}
+
+	containerReference := c.blobClient.GetContainerReference(c.containerName)
+	blobReference := containerReference.GetBlobReference(c.keyName)
+
+	blobReference.Properties.ContentType = "application/json"
+	blobReference.Properties.ContentLength = int64(len(data))
+
+	if c.leaseID != "" {
+		getOptions.LeaseID = c.leaseID
+		setOptions.LeaseID = c.leaseID
+		putOptions.LeaseID = c.leaseID
+	}
+
+	exists, err := blobReference.Exists()
+	if err != nil {
+		return err
+	}
+
+	if exists {
+		err = blobReference.GetMetadata(getOptions)
+		if err != nil {
+			return err
+		}
+	}
+
+	reader := bytes.NewReader(data)
+
+	err = blobReference.CreateBlockBlobFromReader(reader, putOptions)
+	if err != nil {
+		return err
+	}
+
+	return blobReference.SetProperties(setOptions)
+}
+
+func (c *RemoteClient) Delete() error {
+	containerReference := c.blobClient.GetContainerReference(c.containerName)
+	blobReference := containerReference.GetBlobReference(c.keyName)
+	options := &storage.DeleteBlobOptions{}
+
+	if c.leaseID != "" {
+		options.LeaseID = c.leaseID
+	}
+
+	return blobReference.Delete(options)
+}
+
+func (c *RemoteClient) Lock(info *state.LockInfo) (string, error) {
+	stateName := fmt.Sprintf("%s/%s", c.containerName, c.keyName)
+	info.Path = stateName
+
+	if info.ID == "" {
+		lockID, err := uuid.GenerateUUID()
+		if err != nil {
+			return "", err
+		}
+
+		info.ID = lockID
+	}
+
+	getLockInfoErr := func(err error) error {
+		lockInfo, infoErr := c.getLockInfo()
+		if infoErr != nil {
+			err = multierror.Append(err, infoErr)
+		}
+
+		return &state.LockError{
+			Err:  err,
+			Info: lockInfo,
+		}
+	}
+
+	containerReference := c.blobClient.GetContainerReference(c.containerName)
+	blobReference := containerReference.GetBlobReference(c.keyName)
+	leaseID, err := blobReference.AcquireLease(-1, info.ID, &storage.LeaseOptions{})
+	if err != nil {
+		if storErr, ok := err.(storage.AzureStorageServiceError); ok && storErr.Code != "BlobNotFound" {
+			return "", getLockInfoErr(err)
+		}
+
+		// failed to lock as there was no state blob, write empty state
+		stateMgr := &remote.State{Client: c}
+
+		// ensure state is actually empty
+		if err := stateMgr.RefreshState(); err != nil {
+			return "", fmt.Errorf("Failed to refresh state before writing empty state for locking: %s", err)
+		}
+
+		log.Print("[DEBUG] Could not lock as state blob did not exist, creating with empty state")
+
+		if v := stateMgr.State(); v == nil {
+			if err := stateMgr.WriteState(terraform.NewState()); err != nil {
+				return "", fmt.Errorf("Failed to write empty state for locking: %s", err)
+			}
+			if err := stateMgr.PersistState(); err != nil {
+				return "", fmt.Errorf("Failed to persist empty state for locking: %s", err)
+			}
+		}
+
+		leaseID, err = blobReference.AcquireLease(-1, info.ID, &storage.LeaseOptions{})
+		if err != nil {
+			return "", getLockInfoErr(err)
+		}
+	}
+
+	info.ID = leaseID
+	c.leaseID = leaseID
+
+	if err := c.writeLockInfo(info); err != nil {
+		return "", err
+	}
+
+	return info.ID, nil
+}
+
+func (c *RemoteClient) getLockInfo() (*state.LockInfo, error) {
+	containerReference := c.blobClient.GetContainerReference(c.containerName)
+	blobReference := containerReference.GetBlobReference(c.keyName)
+	err := blobReference.GetMetadata(&storage.GetBlobMetadataOptions{})
+	if err != nil {
+		return nil, err
+	}
+
+	raw := blobReference.Metadata[lockInfoMetaKey]
+	if raw == "" {
+		return nil, fmt.Errorf("blob metadata %q was empty", lockInfoMetaKey)
+	}
+
+	data, err := base64.StdEncoding.DecodeString(raw)
+	if err != nil {
+		return nil, err
+	}
+
+	lockInfo := &state.LockInfo{}
+	err = json.Unmarshal(data, lockInfo)
+	if err != nil {
+		return nil, err
+	}
+
+	return lockInfo, nil
+}
+
+// writes info to blob meta data, deletes metadata entry if info is nil
+func (c *RemoteClient) writeLockInfo(info *state.LockInfo) error {
+	containerReference := c.blobClient.GetContainerReference(c.containerName)
+	blobReference := containerReference.GetBlobReference(c.keyName)
+	err := blobReference.GetMetadata(&storage.GetBlobMetadataOptions{
+		LeaseID: c.leaseID,
+	})
+	if err != nil {
+		return err
+	}
+
+	if info == nil {
+		delete(blobReference.Metadata, lockInfoMetaKey)
+	} else {
+		value := base64.StdEncoding.EncodeToString(info.Marshal())
+		blobReference.Metadata[lockInfoMetaKey] = value
+	}
+
+	opts := &storage.SetBlobMetadataOptions{
+		LeaseID: c.leaseID,
+	}
+	return blobReference.SetMetadata(opts)
+}
+
+func (c *RemoteClient) Unlock(id string) error {
+	lockErr := &state.LockError{}
+
+	lockInfo, err := c.getLockInfo()
+	if err != nil {
+		lockErr.Err = fmt.Errorf("failed to retrieve lock info: %s", err)
+		return lockErr
+	}
+	lockErr.Info = lockInfo
+
+	if lockInfo.ID != id {
+		lockErr.Err = fmt.Errorf("lock id %q does not match existing lock", id)
+		return lockErr
+	}
+
+	if err := c.writeLockInfo(nil); err != nil {
+		lockErr.Err = fmt.Errorf("failed to delete lock info from metadata: %s", err)
+		return lockErr
+	}
+
+	containerReference := c.blobClient.GetContainerReference(c.containerName)
+	blobReference := containerReference.GetBlobReference(c.keyName)
+	err = blobReference.ReleaseLease(id, &storage.LeaseOptions{})
+	if err != nil {
+		lockErr.Err = err
+		return lockErr
+	}
+
+	c.leaseID = ""
+
+	return nil
+}
diff --git a/vendor/github.com/hashicorp/terraform/backend/remote-state/etcdv3/backend.go b/vendor/github.com/hashicorp/terraform/backend/remote-state/etcdv3/backend.go
new file mode 100644
index 000000000..fb3f5e202
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/backend/remote-state/etcdv3/backend.go
@@ -0,0 +1,157 @@
+package etcd
+
+import (
+	"context"
+
+	etcdv3 "github.com/coreos/etcd/clientv3"
+	"github.com/coreos/etcd/pkg/transport"
+	"github.com/hashicorp/terraform/backend"
+	"github.com/hashicorp/terraform/helper/schema"
+)
+
+const (
+	endpointsKey       = "endpoints"
+	usernameKey        = "username"
+	usernameEnvVarName = "ETCDV3_USERNAME"
+	passwordKey        = "password"
+	passwordEnvVarName = "ETCDV3_PASSWORD"
+	prefixKey          = "prefix"
+	lockKey            = "lock"
+	cacertPathKey      = "cacert_path"
+	certPathKey        = "cert_path"
+	keyPathKey         = "key_path"
+)
+
+func New() backend.Backend {
+	s := &schema.Backend{
+		Schema: map[string]*schema.Schema{
+			endpointsKey: &schema.Schema{
+				Type: schema.TypeList,
+				Elem: &schema.Schema{
+					Type: schema.TypeString,
+				},
+				MinItems:    1,
+				Required:    true,
+				Description: "Endpoints for the etcd cluster.",
+			},
+
+			usernameKey: &schema.Schema{
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "Username used to connect to the etcd cluster.",
+				DefaultFunc: schema.EnvDefaultFunc(usernameEnvVarName, ""),
+			},
+
+			passwordKey: &schema.Schema{
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "Password used to connect to the etcd cluster.",
+				DefaultFunc: schema.EnvDefaultFunc(passwordEnvVarName, ""),
+			},
+
+			prefixKey: &schema.Schema{
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "An optional prefix to be added to keys when to storing state in etcd.",
+				Default:     "",
+			},
+
+			lockKey: &schema.Schema{
+				Type:        schema.TypeBool,
+				Optional:    true,
+				Description: "Whether to lock state access.",
+				Default:     true,
+			},
+
+			cacertPathKey: &schema.Schema{
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "The path to a PEM-encoded CA bundle with which to verify certificates of TLS-enabled etcd servers.",
+				Default:     "",
+			},
+
+			certPathKey: &schema.Schema{
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "The path to a PEM-encoded certificate to provide to etcd for secure client identification.",
+				Default:     "",
+			},
+
+			keyPathKey: &schema.Schema{
+				Type:        schema.TypeString,
+				Optional:    true,
+				Description: "The path to a PEM-encoded key to provide to etcd for secure client identification.",
+				Default:     "",
+			},
+		},
+	}
+
+	result := &Backend{Backend: s}
+	result.Backend.ConfigureFunc = result.configure
+	return result
+}
+
+type Backend struct {
+	*schema.Backend
+
+	// The fields below are set from configure.
+	client *etcdv3.Client
+	data   *schema.ResourceData
+	lock   bool
+	prefix string
+}
+
+func (b *Backend) configure(ctx context.Context) error {
+	var err error
+	// Grab the resource data.
+	b.data = schema.FromContextBackendConfig(ctx)
+	// Store the lock information.
+	b.lock = b.data.Get(lockKey).(bool)
+	// Store the prefix information.
+	b.prefix = b.data.Get(prefixKey).(string)
+	// Initialize a client to test config.
+	b.client, err = b.rawClient()
+	// Return err, if any.
+	return err
+}
+
+func (b *Backend) rawClient() (*etcdv3.Client, error) {
+	config := etcdv3.Config{}
+	tlsInfo := transport.TLSInfo{}
+
+	if v, ok := b.data.GetOk(endpointsKey); ok {
+		config.Endpoints = retrieveEndpoints(v)
+	}
+	if v, ok := b.data.GetOk(usernameKey); ok && v.(string) != "" {
+		config.Username = v.(string)
+	}
+	if v, ok := b.data.GetOk(passwordKey); ok && v.(string) != "" {
+		config.Password = v.(string)
+	}
+	if v, ok := b.data.GetOk(cacertPathKey); ok && v.(string) != "" {
+		tlsInfo.TrustedCAFile = v.(string)
+	}
+	if v, ok := b.data.GetOk(certPathKey); ok && v.(string) != "" {
+		tlsInfo.CertFile = v.(string)
+	}
+	if v, ok := b.data.GetOk(keyPathKey); ok && v.(string) != "" {
+		tlsInfo.KeyFile = v.(string)
+	}
+
+	if tlsCfg, err := tlsInfo.ClientConfig(); err != nil {
+		return nil, err
+	} else if !tlsInfo.Empty() {
+		config.TLS = tlsCfg // Assign TLS configuration only if it valid and non-empty.
+	}
+
+	return etcdv3.New(config)
+}
+
+func retrieveEndpoints(v interface{}) []string {
+	var endpoints []string
+	list := v.([]interface{})
+	for _, ep := range list {
+		endpoints = append(endpoints, ep.(string))
+	}
+	return endpoints
+}
diff --git a/vendor/github.com/hashicorp/terraform/backend/remote-state/etcdv3/backend_state.go b/vendor/github.com/hashicorp/terraform/backend/remote-state/etcdv3/backend_state.go
new file mode 100644
index 000000000..4c9f78a9b
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/backend/remote-state/etcdv3/backend_state.go
@@ -0,0 +1,103 @@
+package etcd
+
+import (
+	"context"
+	"fmt"
+	"sort"
+	"strings"
+
+	etcdv3 "github.com/coreos/etcd/clientv3"
+	"github.com/hashicorp/terraform/backend"
+	"github.com/hashicorp/terraform/state"
+	"github.com/hashicorp/terraform/state/remote"
+	"github.com/hashicorp/terraform/terraform"
+)
+
+func (b *Backend) States() ([]string, error) {
+	res, err := b.client.Get(context.TODO(), b.prefix, etcdv3.WithPrefix(), etcdv3.WithKeysOnly())
+	if err != nil {
+		return nil, err
+	}
+
+	result := make([]string, 1, len(res.Kvs)+1)
+	result[0] = backend.DefaultStateName
+	for _, kv := range res.Kvs {
+		result = append(result, strings.TrimPrefix(string(kv.Key), b.prefix))
+	}
+	sort.Strings(result[1:])
+
+	return result, nil
+}
+
+func (b *Backend) DeleteState(name string) error {
+	if name == backend.DefaultStateName || name == "" {
+		return fmt.Errorf("Can't delete default state.")
+	}
+
+	key := b.determineKey(name)
+
+	_, err := b.client.Delete(context.TODO(), key)
+	return err
+}
+
+func (b *Backend) State(name string) (state.State, error) {
+	var stateMgr state.State = &remote.State{
+		Client: &RemoteClient{
+			Client: b.client,
+			DoLock: b.lock,
+			Key:    b.determineKey(name),
+		},
+	}
+
+	if !b.lock {
+		stateMgr = &state.LockDisabled{Inner: stateMgr}
+	}
+
+	lockInfo := state.NewLockInfo()
+	lockInfo.Operation = "init"
+	lockId, err := stateMgr.Lock(lockInfo)
+	if err != nil {
+		return nil, fmt.Errorf("Failed to lock state in etcd: %s.", err)
+	}
+
+	lockUnlock := func(parent error) error {
+		if err := stateMgr.Unlock(lockId); err != nil {
+			return fmt.Errorf(strings.TrimSpace(errStateUnlock), lockId, err)
+		}
+		return parent
+	}
+
+	if err := stateMgr.RefreshState(); err != nil {
+		err = lockUnlock(err)
+		return nil, err
+	}
+
+	if v := stateMgr.State(); v == nil {
+		if err := stateMgr.WriteState(terraform.NewState()); err != nil {
+			err = lockUnlock(err)
+			return nil, err
+		}
+		if err := stateMgr.PersistState(); err != nil {
+			err = lockUnlock(err)
+			return nil, err
+		}
+	}
+
+	if err := lockUnlock(nil); err != nil {
+		return nil, err
+	}
+
+	return stateMgr, nil
+}
+
+func (b *Backend) determineKey(name string) string {
+	return b.prefix + name
+}
+
+const errStateUnlock = `
+Error unlocking etcd state. Lock ID: %s
+
+Error: %s
+
+You may have to force-unlock this state in order to use it again.
+`
diff --git a/vendor/github.com/hashicorp/terraform/backend/remote-state/etcdv3/client.go b/vendor/github.com/hashicorp/terraform/backend/remote-state/etcdv3/client.go
new file mode 100644
index 000000000..155e8d8c1
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/backend/remote-state/etcdv3/client.go
@@ -0,0 +1,211 @@
+package etcd
+
+import (
+	"context"
+	"crypto/md5"
+	"encoding/json"
+	"fmt"
+	"sync"
+	"time"
+
+	etcdv3 "github.com/coreos/etcd/clientv3"
+	etcdv3sync "github.com/coreos/etcd/clientv3/concurrency"
+	"github.com/hashicorp/go-multierror"
+	"github.com/hashicorp/terraform/state"
+	"github.com/hashicorp/terraform/state/remote"
+)
+
+const (
+	lockAcquireTimeout = 2 * time.Second
+	lockInfoSuffix     = ".lockinfo"
+)
+
+// RemoteClient is a remote client that will store data in etcd.
+type RemoteClient struct {
+	Client *etcdv3.Client
+	DoLock bool
+	Key    string
+
+	etcdMutex   *etcdv3sync.Mutex
+	etcdSession *etcdv3sync.Session
+	info        *state.LockInfo
+	mu          sync.Mutex
+	modRevision int64
+}
+
+func (c *RemoteClient) Get() (*remote.Payload, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	res, err := c.Client.KV.Get(context.TODO(), c.Key)
+	if err != nil {
+		return nil, err
+	}
+	if res.Count == 0 {
+		return nil, nil
+	}
+	if res.Count >= 2 {
+		return nil, fmt.Errorf("Expected a single result but got %d.", res.Count)
+	}
+
+	c.modRevision = res.Kvs[0].ModRevision
+
+	payload := res.Kvs[0].Value
+	md5 := md5.Sum(payload)
+
+	return &remote.Payload{
+		Data: payload,
+		MD5:  md5[:],
+	}, nil
+}
+
+func (c *RemoteClient) Put(data []byte) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	res, err := etcdv3.NewKV(c.Client).Txn(context.TODO()).If(
+		etcdv3.Compare(etcdv3.ModRevision(c.Key), "=", c.modRevision),
+	).Then(
+		etcdv3.OpPut(c.Key, string(data)),
+		etcdv3.OpGet(c.Key),
+	).Commit()
+
+	if err != nil {
+		return err
+	}
+	if !res.Succeeded {
+		return fmt.Errorf("The transaction did not succeed.")
+	}
+	if len(res.Responses) != 2 {
+		return fmt.Errorf("Expected two responses but got %d.", len(res.Responses))
+	}
+
+	c.modRevision = res.Responses[1].GetResponseRange().Kvs[0].ModRevision
+	return nil
+}
+
+func (c *RemoteClient) Delete() error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	_, err := c.Client.KV.Delete(context.TODO(), c.Key)
+	return err
+}
+
+func (c *RemoteClient) Lock(info *state.LockInfo) (string, error) {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if !c.DoLock {
+		return "", nil
+	}
+	if c.etcdSession != nil {
+		return "", fmt.Errorf("state %q already locked", c.Key)
+	}
+
+	c.info = info
+	return c.lock()
+}
+
+func (c *RemoteClient) Unlock(id string) error {
+	c.mu.Lock()
+	defer c.mu.Unlock()
+
+	if !c.DoLock {
+		return nil
+	}
+
+	return c.unlock(id)
+}
+
+func (c *RemoteClient) deleteLockInfo(info *state.LockInfo) error {
+	res, err := c.Client.KV.Delete(context.TODO(), c.Key+lockInfoSuffix)
+	if err != nil {
+		return err
+	}
+	if res.Deleted == 0 {
+		return fmt.Errorf("No keys deleted for %s when deleting lock info.", c.Key+lockInfoSuffix)
+	}
+	return nil
+}
+
+func (c *RemoteClient) getLockInfo() (*state.LockInfo, error) {
+	res, err := c.Client.KV.Get(context.TODO(), c.Key+lockInfoSuffix)
+	if err != nil {
+		return nil, err
+	}
+	if res.Count == 0 {
+		return nil, nil
+	}
+
+	li := &state.LockInfo{}
+	err = json.Unmarshal(res.Kvs[0].Value, li)
+	if err != nil {
+		return nil, fmt.Errorf("Error unmarshaling lock info: %s.", err)
+	}
+
+	return li, nil
+}
+
+func (c *RemoteClient) putLockInfo(info *state.LockInfo) error {
+	c.info.Path = c.etcdMutex.Key()
+	c.info.Created = time.Now().UTC()
+
+	_, err := c.Client.KV.Put(context.TODO(), c.Key+lockInfoSuffix, string(c.info.Marshal()))
+	return err
+}
+
+func (c *RemoteClient) lock() (string, error) {
+	session, err := etcdv3sync.NewSession(c.Client)
+	if err != nil {
+		return "", nil
+	}
+
+	ctx, cancel := context.WithTimeout(context.TODO(), lockAcquireTimeout)
+	defer cancel()
+
+	mutex := etcdv3sync.NewMutex(session, c.Key)
+	if err1 := mutex.Lock(ctx); err1 != nil {
+		lockInfo, err2 := c.getLockInfo()
+		if err2 != nil {
+			return "", &state.LockError{Err: err2}
+		}
+		return "", &state.LockError{Info: lockInfo, Err: err1}
+	}
+
+	c.etcdMutex = mutex
+	c.etcdSession = session
+
+	err = c.putLockInfo(c.info)
+	if err != nil {
+		if unlockErr := c.unlock(c.info.ID); unlockErr != nil {
+			err = multierror.Append(err, unlockErr)
+		}
+		return "", err
+	}
+
+	return c.info.ID, nil
+}
+
+func (c *RemoteClient) unlock(id string) error {
+	if c.etcdMutex == nil {
+		return nil
+	}
+
+	var errs error
+
+	if err := c.deleteLockInfo(c.info); err != nil {
+		errs = multierror.Append(errs, err)
+	}
+	if err := c.etcdMutex.Unlock(context.TODO()); err != nil {
+		errs = multierror.Append(errs, err)
+	}
+	if err := c.etcdSession.Close(); err != nil {
+		errs = multierror.Append(errs, err)
+	}
+
+	c.etcdMutex = nil
+	c.etcdSession = nil
+
+	return errs
+}
diff --git a/vendor/github.com/hashicorp/terraform/config/configschema/decoder_spec.go b/vendor/github.com/hashicorp/terraform/config/configschema/decoder_spec.go
new file mode 100644
index 000000000..2b1b0cacb
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/configschema/decoder_spec.go
@@ -0,0 +1,97 @@
+package configschema
+
+import (
+	"github.com/hashicorp/hcl2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+var mapLabelNames = []string{"key"}
+
+// DecoderSpec returns a hcldec.Spec that can be used to decode a HCL Body
+// using the facilities in the hcldec package.
+//
+// The returned specification is guaranteed to return a value of the same type
+// returned by method ImpliedType, but it may contain null or unknown values if
+// any of the block attributes are defined as optional and/or computed
+// respectively.
+func (b *Block) DecoderSpec() hcldec.Spec {
+	ret := hcldec.ObjectSpec{}
+	if b == nil {
+		return ret
+	}
+
+	for name, attrS := range b.Attributes {
+		switch {
+		case attrS.Computed && attrS.Optional:
+			// In this special case we use an unknown value as a default
+			// to get the intended behavior that the result is computed
+			// unless it has been explicitly set in config.
+			ret[name] = &hcldec.DefaultSpec{
+				Primary: &hcldec.AttrSpec{
+					Name: name,
+					Type: attrS.Type,
+				},
+				Default: &hcldec.LiteralSpec{
+					Value: cty.UnknownVal(attrS.Type),
+				},
+			}
+		case attrS.Computed:
+			ret[name] = &hcldec.LiteralSpec{
+				Value: cty.UnknownVal(attrS.Type),
+			}
+		default:
+			ret[name] = &hcldec.AttrSpec{
+				Name:     name,
+				Type:     attrS.Type,
+				Required: attrS.Required,
+			}
+		}
+	}
+
+	for name, blockS := range b.BlockTypes {
+		if _, exists := ret[name]; exists {
+			// This indicates an invalid schema, since it's not valid to
+			// define both an attribute and a block type of the same name.
+			// However, we don't raise this here since it's checked by
+			// InternalValidate.
+			continue
+		}
+
+		childSpec := blockS.Block.DecoderSpec()
+
+		switch blockS.Nesting {
+		case NestingSingle:
+			ret[name] = &hcldec.BlockSpec{
+				TypeName: name,
+				Nested:   childSpec,
+				Required: blockS.MinItems == 1 && blockS.MaxItems >= 1,
+			}
+		case NestingList:
+			ret[name] = &hcldec.BlockListSpec{
+				TypeName: name,
+				Nested:   childSpec,
+				MinItems: blockS.MinItems,
+				MaxItems: blockS.MaxItems,
+			}
+		case NestingSet:
+			ret[name] = &hcldec.BlockSetSpec{
+				TypeName: name,
+				Nested:   childSpec,
+				MinItems: blockS.MinItems,
+				MaxItems: blockS.MaxItems,
+			}
+		case NestingMap:
+			ret[name] = &hcldec.BlockMapSpec{
+				TypeName:   name,
+				Nested:     childSpec,
+				LabelNames: mapLabelNames,
+			}
+		default:
+			// Invalid nesting type is just ignored. It's checked by
+			// InternalValidate.
+			continue
+		}
+	}
+
+	return ret
+}
diff --git a/vendor/github.com/hashicorp/terraform/config/configschema/doc.go b/vendor/github.com/hashicorp/terraform/config/configschema/doc.go
new file mode 100644
index 000000000..caf8d730c
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/configschema/doc.go
@@ -0,0 +1,14 @@
+// Package configschema contains types for describing the expected structure
+// of a configuration block whose shape is not known until runtime.
+//
+// For example, this is used to describe the expected contents of a resource
+// configuration block, which is defined by the corresponding provider plugin
+// and thus not compiled into Terraform core.
+//
+// A configschema primarily describes the shape of configuration, but it is
+// also suitable for use with other structures derived from the configuration,
+// such as the cached state of a resource or a resource diff.
+//
+// This package should not be confused with the package helper/schema, which
+// is the higher-level helper library used to implement providers themselves.
+package configschema
diff --git a/vendor/github.com/hashicorp/terraform/config/configschema/implied_type.go b/vendor/github.com/hashicorp/terraform/config/configschema/implied_type.go
new file mode 100644
index 000000000..67324ebce
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/configschema/implied_type.go
@@ -0,0 +1,21 @@
+package configschema
+
+import (
+	"github.com/hashicorp/hcl2/hcldec"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// ImpliedType returns the cty.Type that would result from decoding a
+// configuration block using the receiving block schema.
+//
+// ImpliedType always returns a result, even if the given schema is
+// inconsistent. Code that creates configschema.Block objects should be
+// tested using the InternalValidate method to detect any inconsistencies
+// that would cause this method to fall back on defaults and assumptions.
+func (b *Block) ImpliedType() cty.Type {
+	if b == nil {
+		return cty.EmptyObject
+	}
+
+	return hcldec.ImpliedType(b.DecoderSpec())
+}
diff --git a/vendor/github.com/hashicorp/terraform/config/configschema/internal_validate.go b/vendor/github.com/hashicorp/terraform/config/configschema/internal_validate.go
new file mode 100644
index 000000000..33cbe884f
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/configschema/internal_validate.go
@@ -0,0 +1,92 @@
+package configschema
+
+import (
+	"fmt"
+	"regexp"
+
+	"github.com/zclconf/go-cty/cty"
+
+	multierror "github.com/hashicorp/go-multierror"
+)
+
+var validName = regexp.MustCompile(`^[a-z0-9_]+$`)
+
+// InternalValidate returns an error if the receiving block and its child
+// schema definitions have any consistencies with the documented rules for
+// valid schema.
+//
+// This is intended to be used within unit tests to detect when a given
+// schema is invalid.
+func (b *Block) InternalValidate() error {
+	if b == nil {
+		return fmt.Errorf("top-level block schema is nil")
+	}
+	return b.internalValidate("", nil)
+
+}
+
+func (b *Block) internalValidate(prefix string, err error) error {
+	for name, attrS := range b.Attributes {
+		if attrS == nil {
+			err = multierror.Append(err, fmt.Errorf("%s%s: attribute schema is nil", prefix, name))
+			continue
+		}
+		if !validName.MatchString(name) {
+			err = multierror.Append(err, fmt.Errorf("%s%s: name may contain only lowercase letters, digits and underscores", prefix, name))
+		}
+		if attrS.Optional == false && attrS.Required == false && attrS.Computed == false {
+			err = multierror.Append(err, fmt.Errorf("%s%s: must set Optional, Required or Computed", prefix, name))
+		}
+		if attrS.Optional && attrS.Required {
+			err = multierror.Append(err, fmt.Errorf("%s%s: cannot set both Optional and Required", prefix, name))
+		}
+		if attrS.Computed && attrS.Required {
+			err = multierror.Append(err, fmt.Errorf("%s%s: cannot set both Computed and Required", prefix, name))
+		}
+		if attrS.Type == cty.NilType {
+			err = multierror.Append(err, fmt.Errorf("%s%s: Type must be set to something other than cty.NilType", prefix, name))
+		}
+	}
+
+	for name, blockS := range b.BlockTypes {
+		if blockS == nil {
+			err = multierror.Append(err, fmt.Errorf("%s%s: block schema is nil", prefix, name))
+			continue
+		}
+
+		if _, isAttr := b.Attributes[name]; isAttr {
+			err = multierror.Append(err, fmt.Errorf("%s%s: name defined as both attribute and child block type", prefix, name))
+		} else if !validName.MatchString(name) {
+			err = multierror.Append(err, fmt.Errorf("%s%s: name may contain only lowercase letters, digits and underscores", prefix, name))
+		}
+
+		if blockS.MinItems < 0 || blockS.MaxItems < 0 {
+			err = multierror.Append(err, fmt.Errorf("%s%s: MinItems and MaxItems must both be greater than zero", prefix, name))
+		}
+
+		switch blockS.Nesting {
+		case NestingSingle:
+			switch {
+			case blockS.MinItems != blockS.MaxItems:
+				err = multierror.Append(err, fmt.Errorf("%s%s: MinItems and MaxItems must match in NestingSingle mode", prefix, name))
+			case blockS.MinItems < 0 || blockS.MinItems > 1:
+				err = multierror.Append(err, fmt.Errorf("%s%s: MinItems and MaxItems must be set to either 0 or 1 in NestingSingle mode", prefix, name))
+			}
+		case NestingList, NestingSet:
+			if blockS.MinItems > blockS.MaxItems && blockS.MaxItems != 0 {
+				err = multierror.Append(err, fmt.Errorf("%s%s: MinItems must be less than or equal to MaxItems in %s mode", prefix, name, blockS.Nesting))
+			}
+		case NestingMap:
+			if blockS.MinItems != 0 || blockS.MaxItems != 0 {
+				err = multierror.Append(err, fmt.Errorf("%s%s: MinItems and MaxItems must both be 0 in NestingMap mode", prefix, name))
+			}
+		default:
+			err = multierror.Append(err, fmt.Errorf("%s%s: invalid nesting mode %s", prefix, name, blockS.Nesting))
+		}
+
+		subPrefix := prefix + name + "."
+		err = blockS.Block.internalValidate(subPrefix, err)
+	}
+
+	return err
+}
diff --git a/vendor/github.com/hashicorp/terraform/config/configschema/nestingmode_string.go b/vendor/github.com/hashicorp/terraform/config/configschema/nestingmode_string.go
new file mode 100644
index 000000000..d9253a20f
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/configschema/nestingmode_string.go
@@ -0,0 +1,16 @@
+// Code generated by "stringer -type=NestingMode"; DO NOT EDIT.
+
+package configschema
+
+import "fmt"
+
+const _NestingMode_name = "nestingModeInvalidNestingSingleNestingListNestingSetNestingMap"
+
+var _NestingMode_index = [...]uint8{0, 18, 31, 42, 52, 62}
+
+func (i NestingMode) String() string {
+	if i < 0 || i >= NestingMode(len(_NestingMode_index)-1) {
+		return fmt.Sprintf("NestingMode(%d)", i)
+	}
+	return _NestingMode_name[_NestingMode_index[i]:_NestingMode_index[i+1]]
+}
diff --git a/vendor/github.com/hashicorp/terraform/config/configschema/schema.go b/vendor/github.com/hashicorp/terraform/config/configschema/schema.go
new file mode 100644
index 000000000..9a8ee550a
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/configschema/schema.go
@@ -0,0 +1,107 @@
+package configschema
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// Block represents a configuration block.
+//
+// "Block" here is a logical grouping construct, though it happens to map
+// directly onto the physical block syntax of Terraform's native configuration
+// syntax. It may be a more a matter of convention in other syntaxes, such as
+// JSON.
+//
+// When converted to a value, a Block always becomes an instance of an object
+// type derived from its defined attributes and nested blocks
+type Block struct {
+	// Attributes describes any attributes that may appear directly inside
+	// the block.
+	Attributes map[string]*Attribute
+
+	// BlockTypes describes any nested block types that may appear directly
+	// inside the block.
+	BlockTypes map[string]*NestedBlock
+}
+
+// Attribute represents a configuration attribute, within a block.
+type Attribute struct {
+	// Type is a type specification that the attribute's value must conform to.
+	Type cty.Type
+
+	// Required, if set to true, specifies that an omitted or null value is
+	// not permitted.
+	Required bool
+
+	// Optional, if set to true, specifies that an omitted or null value is
+	// permitted. This field conflicts with Required.
+	Optional bool
+
+	// Computed, if set to true, specifies that the value comes from the
+	// provider rather than from configuration. If combined with Optional,
+	// then the config may optionally provide an overridden value.
+	Computed bool
+
+	// Sensitive, if set to true, indicates that an attribute may contain
+	// sensitive information.
+	//
+	// At present nothing is done with this information, but callers are
+	// encouraged to set it where appropriate so that it may be used in the
+	// future to help Terraform mask sensitive information. (Terraform
+	// currently achieves this in a limited sense via other mechanisms.)
+	Sensitive bool
+}
+
+// NestedBlock represents the embedding of one block within another.
+type NestedBlock struct {
+	// Block is the description of the block that's nested.
+	Block
+
+	// Nesting provides the nesting mode for the child block, which determines
+	// how many instances of the block are allowed, how many labels it expects,
+	// and how the resulting data will be converted into a data structure.
+	Nesting NestingMode
+
+	// MinItems and MaxItems set, for the NestingList and NestingSet nesting
+	// modes, lower and upper limits on the number of child blocks allowed
+	// of the given type. If both are left at zero, no limit is applied.
+	//
+	// As a special case, both values can be set to 1 for NestingSingle in
+	// order to indicate that a particular single block is required.
+	//
+	// These fields are ignored for other nesting modes and must both be left
+	// at zero.
+	MinItems, MaxItems int
+}
+
+// NestingMode is an enumeration of modes for nesting blocks inside other
+// blocks.
+type NestingMode int
+
+//go:generate stringer -type=NestingMode
+
+const (
+	nestingModeInvalid NestingMode = iota
+
+	// NestingSingle indicates that only a single instance of a given
+	// block type is permitted, with no labels, and its content should be
+	// provided directly as an object value.
+	NestingSingle
+
+	// NestingList indicates that multiple blocks of the given type are
+	// permitted, with no labels, and that their corresponding objects should
+	// be provided in a list.
+	NestingList
+
+	// NestingSet indicates that multiple blocks of the given type are
+	// permitted, with no labels, and that their corresponding objects should
+	// be provided in a set.
+	NestingSet
+
+	// NestingMap indicates that multiple blocks of the given type are
+	// permitted, each with a single label, and that their corresponding
+	// objects should be provided in a map whose keys are the labels.
+	//
+	// It's an error, therefore, to use the same label value on multiple
+	// blocks.
+	NestingMap
+)
diff --git a/vendor/github.com/hashicorp/terraform/config/hcl2shim/single_attr_body.go b/vendor/github.com/hashicorp/terraform/config/hcl2shim/single_attr_body.go
new file mode 100644
index 000000000..19651c81c
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/hcl2shim/single_attr_body.go
@@ -0,0 +1,85 @@
+package hcl2shim
+
+import (
+	"fmt"
+
+	hcl2 "github.com/hashicorp/hcl2/hcl"
+)
+
+// SingleAttrBody is a weird implementation of hcl2.Body that acts as if
+// it has a single attribute whose value is the given expression.
+//
+// This is used to shim Resource.RawCount and Output.RawConfig to behave
+// more like they do in the old HCL loader.
+type SingleAttrBody struct {
+	Name string
+	Expr hcl2.Expression
+}
+
+var _ hcl2.Body = SingleAttrBody{}
+
+func (b SingleAttrBody) Content(schema *hcl2.BodySchema) (*hcl2.BodyContent, hcl2.Diagnostics) {
+	content, all, diags := b.content(schema)
+	if !all {
+		// This should never happen because this body implementation should only
+		// be used by code that is aware that it's using a single-attr body.
+		diags = append(diags, &hcl2.Diagnostic{
+			Severity: hcl2.DiagError,
+			Summary:  "Invalid attribute",
+			Detail:   fmt.Sprintf("The correct attribute name is %q.", b.Name),
+			Subject:  b.Expr.Range().Ptr(),
+		})
+	}
+	return content, diags
+}
+
+func (b SingleAttrBody) PartialContent(schema *hcl2.BodySchema) (*hcl2.BodyContent, hcl2.Body, hcl2.Diagnostics) {
+	content, all, diags := b.content(schema)
+	var remain hcl2.Body
+	if all {
+		// If the request matched the one attribute we represent, then the
+		// remaining body is empty.
+		remain = hcl2.EmptyBody()
+	} else {
+		remain = b
+	}
+	return content, remain, diags
+}
+
+func (b SingleAttrBody) content(schema *hcl2.BodySchema) (*hcl2.BodyContent, bool, hcl2.Diagnostics) {
+	ret := &hcl2.BodyContent{}
+	all := false
+	var diags hcl2.Diagnostics
+
+	for _, attrS := range schema.Attributes {
+		if attrS.Name == b.Name {
+			attrs, _ := b.JustAttributes()
+			ret.Attributes = attrs
+			all = true
+		} else if attrS.Required {
+			diags = append(diags, &hcl2.Diagnostic{
+				Severity: hcl2.DiagError,
+				Summary:  "Missing attribute",
+				Detail:   fmt.Sprintf("The attribute %q is required.", attrS.Name),
+				Subject:  b.Expr.Range().Ptr(),
+			})
+		}
+	}
+
+	return ret, all, diags
+}
+
+func (b SingleAttrBody) JustAttributes() (hcl2.Attributes, hcl2.Diagnostics) {
+	return hcl2.Attributes{
+		b.Name: {
+			Expr:      b.Expr,
+			Name:      b.Name,
+			NameRange: b.Expr.Range(),
+			Range:     b.Expr.Range(),
+		},
+	}, nil
+}
+
+func (b SingleAttrBody) MissingItemRange() hcl2.Range {
+	return b.Expr.Range()
+}
diff --git a/vendor/github.com/hashicorp/terraform/config/hcl2shim/values.go b/vendor/github.com/hashicorp/terraform/config/hcl2shim/values.go
new file mode 100644
index 000000000..0b697a5f5
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/config/hcl2shim/values.go
@@ -0,0 +1,246 @@
+package hcl2shim
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/hashicorp/hil/ast"
+	"github.com/zclconf/go-cty/cty"
+)
+
+// UnknownVariableValue is a sentinel value that can be used
+// to denote that the value of a variable is unknown at this time.
+// RawConfig uses this information to build up data about
+// unknown keys.
+const UnknownVariableValue = "74D93920-ED26-11E3-AC10-0800200C9A66"
+
+// ConfigValueFromHCL2 converts a value from HCL2 (really, from the cty dynamic
+// types library that HCL2 uses) to a value type that matches what would've
+// been produced from the HCL-based interpolator for an equivalent structure.
+//
+// This function will transform a cty null value into a Go nil value, which
+// isn't a possible outcome of the HCL/HIL-based decoder and so callers may
+// need to detect and reject any null values.
+func ConfigValueFromHCL2(v cty.Value) interface{} {
+	if !v.IsKnown() {
+		return UnknownVariableValue
+	}
+	if v.IsNull() {
+		return nil
+	}
+
+	switch v.Type() {
+	case cty.Bool:
+		return v.True() // like HCL.BOOL
+	case cty.String:
+		return v.AsString() // like HCL token.STRING or token.HEREDOC
+	case cty.Number:
+		// We can't match HCL _exactly_ here because it distinguishes between
+		// int and float values, but we'll get as close as we can by using
+		// an int if the number is exactly representable, and a float if not.
+		// The conversion to float will force precision to that of a float64,
+		// which is potentially losing information from the specific number
+		// given, but no worse than what HCL would've done in its own conversion
+		// to float.
+
+		f := v.AsBigFloat()
+		if i, acc := f.Int64(); acc == big.Exact {
+			// if we're on a 32-bit system and the number is too big for 32-bit
+			// int then we'll fall through here and use a float64.
+			const MaxInt = int(^uint(0) >> 1)
+			const MinInt = -MaxInt - 1
+			if i <= int64(MaxInt) && i >= int64(MinInt) {
+				return int(i) // Like HCL token.NUMBER
+			}
+		}
+
+		f64, _ := f.Float64()
+		return f64 // like HCL token.FLOAT
+	}
+
+	if v.Type().IsListType() || v.Type().IsSetType() || v.Type().IsTupleType() {
+		l := make([]interface{}, 0, v.LengthInt())
+		it := v.ElementIterator()
+		for it.Next() {
+			_, ev := it.Element()
+			l = append(l, ConfigValueFromHCL2(ev))
+		}
+		return l
+	}
+
+	if v.Type().IsMapType() || v.Type().IsObjectType() {
+		l := make(map[string]interface{})
+		it := v.ElementIterator()
+		for it.Next() {
+			ek, ev := it.Element()
+			l[ek.AsString()] = ConfigValueFromHCL2(ev)
+		}
+		return l
+	}
+
+	// If we fall out here then we have some weird type that we haven't
+	// accounted for. This should never happen unless the caller is using
+	// capsule types, and we don't currently have any such types defined.
+	panic(fmt.Errorf("can't convert %#v to config value", v))
+}
+
+// HCL2ValueFromConfigValue is the opposite of configValueFromHCL2: it takes
+// a value as would be returned from the old interpolator and turns it into
+// a cty.Value so it can be used within, for example, an HCL2 EvalContext.
+func HCL2ValueFromConfigValue(v interface{}) cty.Value {
+	if v == nil {
+		return cty.NullVal(cty.DynamicPseudoType)
+	}
+	if v == UnknownVariableValue {
+		return cty.DynamicVal
+	}
+
+	switch tv := v.(type) {
+	case bool:
+		return cty.BoolVal(tv)
+	case string:
+		return cty.StringVal(tv)
+	case int:
+		return cty.NumberIntVal(int64(tv))
+	case float64:
+		return cty.NumberFloatVal(tv)
+	case []interface{}:
+		vals := make([]cty.Value, len(tv))
+		for i, ev := range tv {
+			vals[i] = HCL2ValueFromConfigValue(ev)
+		}
+		return cty.TupleVal(vals)
+	case map[string]interface{}:
+		vals := map[string]cty.Value{}
+		for k, ev := range tv {
+			vals[k] = HCL2ValueFromConfigValue(ev)
+		}
+		return cty.ObjectVal(vals)
+	default:
+		// HCL/HIL should never generate anything that isn't caught by
+		// the above, so if we get here something has gone very wrong.
+		panic(fmt.Errorf("can't convert %#v to cty.Value", v))
+	}
+}
+
+func HILVariableFromHCL2Value(v cty.Value) ast.Variable {
+	if v.IsNull() {
+		// Caller should guarantee/check this before calling
+		panic("Null values cannot be represented in HIL")
+	}
+	if !v.IsKnown() {
+		return ast.Variable{
+			Type:  ast.TypeUnknown,
+			Value: UnknownVariableValue,
+		}
+	}
+
+	switch v.Type() {
+	case cty.Bool:
+		return ast.Variable{
+			Type:  ast.TypeBool,
+			Value: v.True(),
+		}
+	case cty.Number:
+		v := ConfigValueFromHCL2(v)
+		switch tv := v.(type) {
+		case int:
+			return ast.Variable{
+				Type:  ast.TypeInt,
+				Value: tv,
+			}
+		case float64:
+			return ast.Variable{
+				Type:  ast.TypeFloat,
+				Value: tv,
+			}
+		default:
+			// should never happen
+			panic("invalid return value for configValueFromHCL2")
+		}
+	case cty.String:
+		return ast.Variable{
+			Type:  ast.TypeString,
+			Value: v.AsString(),
+		}
+	}
+
+	if v.Type().IsListType() || v.Type().IsSetType() || v.Type().IsTupleType() {
+		l := make([]ast.Variable, 0, v.LengthInt())
+		it := v.ElementIterator()
+		for it.Next() {
+			_, ev := it.Element()
+			l = append(l, HILVariableFromHCL2Value(ev))
+		}
+		// If we were given a tuple then this could actually produce an invalid
+		// list with non-homogenous types, which we expect to be caught inside
+		// HIL just like a user-supplied non-homogenous list would be.
+		return ast.Variable{
+			Type:  ast.TypeList,
+			Value: l,
+		}
+	}
+
+	if v.Type().IsMapType() || v.Type().IsObjectType() {
+		l := make(map[string]ast.Variable)
+		it := v.ElementIterator()
+		for it.Next() {
+			ek, ev := it.Element()
+			l[ek.AsString()] = HILVariableFromHCL2Value(ev)
+		}
+		// If we were given an object then this could actually produce an invalid
+		// map with non-homogenous types, which we expect to be caught inside
+		// HIL just like a user-supplied non-homogenous map would be.
+		return ast.Variable{
+			Type:  ast.TypeMap,
+			Value: l,
+		}
+	}
+
+	// If we fall out here then we have some weird type that we haven't
+	// accounted for. This should never happen unless the caller is using
+	// capsule types, and we don't currently have any such types defined.
+	panic(fmt.Errorf("can't convert %#v to HIL variable", v))
+}
+
+func HCL2ValueFromHILVariable(v ast.Variable) cty.Value {
+	switch v.Type {
+	case ast.TypeList:
+		vals := make([]cty.Value, len(v.Value.([]ast.Variable)))
+		for i, ev := range v.Value.([]ast.Variable) {
+			vals[i] = HCL2ValueFromHILVariable(ev)
+		}
+		return cty.TupleVal(vals)
+	case ast.TypeMap:
+		vals := make(map[string]cty.Value, len(v.Value.(map[string]ast.Variable)))
+		for k, ev := range v.Value.(map[string]ast.Variable) {
+			vals[k] = HCL2ValueFromHILVariable(ev)
+		}
+		return cty.ObjectVal(vals)
+	default:
+		return HCL2ValueFromConfigValue(v.Value)
+	}
+}
+
+func HCL2TypeForHILType(hilType ast.Type) cty.Type {
+	switch hilType {
+	case ast.TypeAny:
+		return cty.DynamicPseudoType
+	case ast.TypeUnknown:
+		return cty.DynamicPseudoType
+	case ast.TypeBool:
+		return cty.Bool
+	case ast.TypeInt:
+		return cty.Number
+	case ast.TypeFloat:
+		return cty.Number
+	case ast.TypeString:
+		return cty.String
+	case ast.TypeList:
+		return cty.List(cty.DynamicPseudoType)
+	case ast.TypeMap:
+		return cty.Map(cty.DynamicPseudoType)
+	default:
+		return cty.NilType // equilvalent to ast.TypeInvalid
+	}
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/diagnostic.go b/vendor/github.com/hashicorp/terraform/tfdiags/diagnostic.go
new file mode 100644
index 000000000..2c23f76ae
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/diagnostic.go
@@ -0,0 +1,26 @@
+package tfdiags
+
+type Diagnostic interface {
+	Severity() Severity
+	Description() Description
+	Source() Source
+}
+
+type Severity rune
+
+//go:generate stringer -type=Severity
+
+const (
+	Error   Severity = 'E'
+	Warning Severity = 'W'
+)
+
+type Description struct {
+	Summary string
+	Detail  string
+}
+
+type Source struct {
+	Subject *SourceRange
+	Context *SourceRange
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/diagnostics.go b/vendor/github.com/hashicorp/terraform/tfdiags/diagnostics.go
new file mode 100644
index 000000000..667ba8096
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/diagnostics.go
@@ -0,0 +1,181 @@
+package tfdiags
+
+import (
+	"bytes"
+	"fmt"
+
+	"github.com/hashicorp/errwrap"
+	multierror "github.com/hashicorp/go-multierror"
+	"github.com/hashicorp/hcl2/hcl"
+)
+
+// Diagnostics is a list of diagnostics. Diagnostics is intended to be used
+// where a Go "error" might normally be used, allowing richer information
+// to be conveyed (more context, support for warnings).
+//
+// A nil Diagnostics is a valid, empty diagnostics list, thus allowing
+// heap allocation to be avoided in the common case where there are no
+// diagnostics to report at all.
+type Diagnostics []Diagnostic
+
+// Append is the main interface for constructing Diagnostics lists, taking
+// an existing list (which may be nil) and appending the new objects to it
+// after normalizing them to be implementations of Diagnostic.
+//
+// The usual pattern for a function that natively "speaks" diagnostics is:
+//
+//     // Create a nil Diagnostics at the start of the function
+//     var diags diag.Diagnostics
+//
+//     // At later points, build on it if errors / warnings occur:
+//     foo, err := DoSomethingRisky()
+//     if err != nil {
+//         diags = diags.Append(err)
+//     }
+//
+//     // Eventually return the result and diagnostics in place of error
+//     return result, diags
+//
+// Append accepts a variety of different diagnostic-like types, including
+// native Go errors and HCL diagnostics. It also knows how to unwrap
+// a multierror.Error into separate error diagnostics. It can be passed
+// another Diagnostics to concatenate the two lists. If given something
+// it cannot handle, this function will panic.
+func (diags Diagnostics) Append(new ...interface{}) Diagnostics {
+	for _, item := range new {
+		if item == nil {
+			continue
+		}
+
+		switch ti := item.(type) {
+		case Diagnostic:
+			diags = append(diags, ti)
+		case Diagnostics:
+			diags = append(diags, ti...) // flatten
+		case diagnosticsAsError:
+			diags = diags.Append(ti.Diagnostics) // unwrap
+		case hcl.Diagnostics:
+			for _, hclDiag := range ti {
+				diags = append(diags, hclDiagnostic{hclDiag})
+			}
+		case *hcl.Diagnostic:
+			diags = append(diags, hclDiagnostic{ti})
+		case *multierror.Error:
+			for _, err := range ti.Errors {
+				diags = append(diags, nativeError{err})
+			}
+		case error:
+			switch {
+			case errwrap.ContainsType(ti, Diagnostics(nil)):
+				// If we have an errwrap wrapper with a Diagnostics hiding
+				// inside then we'll unpick it here to get access to the
+				// individual diagnostics.
+				diags = diags.Append(errwrap.GetType(ti, Diagnostics(nil)))
+			case errwrap.ContainsType(ti, hcl.Diagnostics(nil)):
+				// Likewise, if we have HCL diagnostics we'll unpick that too.
+				diags = diags.Append(errwrap.GetType(ti, hcl.Diagnostics(nil)))
+			default:
+				diags = append(diags, nativeError{ti})
+			}
+		default:
+			panic(fmt.Errorf("can't construct diagnostic(s) from %T", item))
+		}
+	}
+
+	// Given the above, we should never end up with a non-nil empty slice
+	// here, but we'll make sure of that so callers can rely on empty == nil
+	if len(diags) == 0 {
+		return nil
+	}
+
+	return diags
+}
+
+// HasErrors returns true if any of the diagnostics in the list have
+// a severity of Error.
+func (diags Diagnostics) HasErrors() bool {
+	for _, diag := range diags {
+		if diag.Severity() == Error {
+			return true
+		}
+	}
+	return false
+}
+
+// ForRPC returns a version of the receiver that has been simplified so that
+// it is friendly to RPC protocols.
+//
+// Currently this means that it can be serialized with encoding/gob and
+// subsequently re-inflated. It may later grow to include other serialization
+// formats.
+//
+// Note that this loses information about the original objects used to
+// construct the diagnostics, so e.g. the errwrap API will not work as
+// expected on an error-wrapped Diagnostics that came from ForRPC.
+func (diags Diagnostics) ForRPC() Diagnostics {
+	ret := make(Diagnostics, len(diags))
+	for i := range diags {
+		ret[i] = makeRPCFriendlyDiag(diags[i])
+	}
+	return ret
+}
+
+// Err flattens a diagnostics list into a single Go error, or to nil
+// if the diagnostics list does not include any error-level diagnostics.
+//
+// This can be used to smuggle diagnostics through an API that deals in
+// native errors, but unfortunately it will lose naked warnings (warnings
+// that aren't accompanied by at least one error) since such APIs have no
+// mechanism through which to report these.
+//
+//     return result, diags.Error()
+func (diags Diagnostics) Err() error {
+	if !diags.HasErrors() {
+		return nil
+	}
+	return diagnosticsAsError{diags}
+}
+
+type diagnosticsAsError struct {
+	Diagnostics
+}
+
+func (dae diagnosticsAsError) Error() string {
+	diags := dae.Diagnostics
+	switch {
+	case len(diags) == 0:
+		// should never happen, since we don't create this wrapper if
+		// there are no diagnostics in the list.
+		return "no errors"
+	case len(diags) == 1:
+		desc := diags[0].Description()
+		if desc.Detail == "" {
+			return desc.Summary
+		}
+		return fmt.Sprintf("%s: %s", desc.Summary, desc.Detail)
+	default:
+		var ret bytes.Buffer
+		fmt.Fprintf(&ret, "%d problems:\n", len(diags))
+		for _, diag := range dae.Diagnostics {
+			desc := diag.Description()
+			if desc.Detail == "" {
+				fmt.Fprintf(&ret, "\n- %s", desc.Summary)
+			} else {
+				fmt.Fprintf(&ret, "\n- %s: %s", desc.Summary, desc.Detail)
+			}
+		}
+		return ret.String()
+	}
+}
+
+// WrappedErrors is an implementation of errwrap.Wrapper so that an error-wrapped
+// diagnostics object can be picked apart by errwrap-aware code.
+func (dae diagnosticsAsError) WrappedErrors() []error {
+	var errs []error
+	for _, diag := range dae.Diagnostics {
+		if wrapper, isErr := diag.(nativeError); isErr {
+			errs = append(errs, wrapper.err)
+		}
+	}
+	return errs
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/doc.go b/vendor/github.com/hashicorp/terraform/tfdiags/doc.go
new file mode 100644
index 000000000..c427879eb
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/doc.go
@@ -0,0 +1,16 @@
+// Package tfdiags is a utility package for representing errors and
+// warnings in a manner that allows us to produce good messages for the
+// user.
+//
+// "diag" is short for "diagnostics", and is meant as a general word for
+// feedback to a user about potential or actual problems.
+//
+// A design goal for this package is for it to be able to provide rich
+// messaging where possible but to also be pragmatic about dealing with
+// generic errors produced by system components that _can't_ provide
+// such rich messaging. As a consequence, the main types in this package --
+// Diagnostics and Diagnostic -- are designed so that they can be "smuggled"
+// over an error channel and then be unpacked at the other end, so that
+// error diagnostics (at least) can transit through APIs that are not
+// aware of this package.
+package tfdiags
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/error.go b/vendor/github.com/hashicorp/terraform/tfdiags/error.go
new file mode 100644
index 000000000..35edc3041
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/error.go
@@ -0,0 +1,23 @@
+package tfdiags
+
+// nativeError is a Diagnostic implementation that wraps a normal Go error
+type nativeError struct {
+	err error
+}
+
+var _ Diagnostic = nativeError{}
+
+func (e nativeError) Severity() Severity {
+	return Error
+}
+
+func (e nativeError) Description() Description {
+	return Description{
+		Summary: e.err.Error(),
+	}
+}
+
+func (e nativeError) Source() Source {
+	// No source information available for a native error
+	return Source{}
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/hcl.go b/vendor/github.com/hashicorp/terraform/tfdiags/hcl.go
new file mode 100644
index 000000000..24851f4d0
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/hcl.go
@@ -0,0 +1,77 @@
+package tfdiags
+
+import (
+	"github.com/hashicorp/hcl2/hcl"
+)
+
+// hclDiagnostic is a Diagnostic implementation that wraps a HCL Diagnostic
+type hclDiagnostic struct {
+	diag *hcl.Diagnostic
+}
+
+var _ Diagnostic = hclDiagnostic{}
+
+func (d hclDiagnostic) Severity() Severity {
+	switch d.diag.Severity {
+	case hcl.DiagWarning:
+		return Warning
+	default:
+		return Error
+	}
+}
+
+func (d hclDiagnostic) Description() Description {
+	return Description{
+		Summary: d.diag.Summary,
+		Detail:  d.diag.Detail,
+	}
+}
+
+func (d hclDiagnostic) Source() Source {
+	var ret Source
+	if d.diag.Subject != nil {
+		rng := SourceRangeFromHCL(*d.diag.Subject)
+		ret.Subject = &rng
+	}
+	if d.diag.Context != nil {
+		rng := SourceRangeFromHCL(*d.diag.Context)
+		ret.Context = &rng
+	}
+	return ret
+}
+
+// SourceRangeFromHCL constructs a SourceRange from the corresponding range
+// type within the HCL package.
+func SourceRangeFromHCL(hclRange hcl.Range) SourceRange {
+	return SourceRange{
+		Filename: hclRange.Filename,
+		Start: SourcePos{
+			Line:   hclRange.Start.Line,
+			Column: hclRange.Start.Column,
+			Byte:   hclRange.Start.Byte,
+		},
+		End: SourcePos{
+			Line:   hclRange.End.Line,
+			Column: hclRange.End.Column,
+			Byte:   hclRange.End.Byte,
+		},
+	}
+}
+
+// ToHCL constructs a HCL Range from the receiving SourceRange. This is the
+// opposite of SourceRangeFromHCL.
+func (r SourceRange) ToHCL() hcl.Range {
+	return hcl.Range{
+		Filename: r.Filename,
+		Start: hcl.Pos{
+			Line:   r.Start.Line,
+			Column: r.Start.Column,
+			Byte:   r.Start.Byte,
+		},
+		End: hcl.Pos{
+			Line:   r.End.Line,
+			Column: r.End.Column,
+			Byte:   r.End.Byte,
+		},
+	}
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/rpc_friendly.go b/vendor/github.com/hashicorp/terraform/tfdiags/rpc_friendly.go
new file mode 100644
index 000000000..6cc95cc2e
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/rpc_friendly.go
@@ -0,0 +1,53 @@
+package tfdiags
+
+import (
+	"encoding/gob"
+)
+
+type rpcFriendlyDiag struct {
+	Severity_ Severity
+	Summary_  string
+	Detail_   string
+	Subject_  *SourceRange
+	Context_  *SourceRange
+}
+
+// rpcFriendlyDiag transforms a given diagnostic so that is more friendly to
+// RPC.
+//
+// In particular, it currently returns an object that can be serialized and
+// later re-inflated using gob. This definition may grow to include other
+// serializations later.
+func makeRPCFriendlyDiag(diag Diagnostic) Diagnostic {
+	desc := diag.Description()
+	source := diag.Source()
+	return &rpcFriendlyDiag{
+		Severity_: diag.Severity(),
+		Summary_:  desc.Summary,
+		Detail_:   desc.Detail,
+		Subject_:  source.Subject,
+		Context_:  source.Context,
+	}
+}
+
+func (d *rpcFriendlyDiag) Severity() Severity {
+	return d.Severity_
+}
+
+func (d *rpcFriendlyDiag) Description() Description {
+	return Description{
+		Summary: d.Summary_,
+		Detail:  d.Detail_,
+	}
+}
+
+func (d *rpcFriendlyDiag) Source() Source {
+	return Source{
+		Subject: d.Subject_,
+		Context: d.Context_,
+	}
+}
+
+func init() {
+	gob.Register((*rpcFriendlyDiag)(nil))
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/severity_string.go b/vendor/github.com/hashicorp/terraform/tfdiags/severity_string.go
new file mode 100644
index 000000000..edf9e639f
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/severity_string.go
@@ -0,0 +1,26 @@
+// Code generated by "stringer -type=Severity"; DO NOT EDIT.
+
+package tfdiags
+
+import "fmt"
+
+const (
+	_Severity_name_0 = "Error"
+	_Severity_name_1 = "Warning"
+)
+
+var (
+	_Severity_index_0 = [...]uint8{0, 5}
+	_Severity_index_1 = [...]uint8{0, 7}
+)
+
+func (i Severity) String() string {
+	switch {
+	case i == 69:
+		return _Severity_name_0
+	case i == 87:
+		return _Severity_name_1
+	default:
+		return fmt.Sprintf("Severity(%d)", i)
+	}
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/simple_warning.go b/vendor/github.com/hashicorp/terraform/tfdiags/simple_warning.go
new file mode 100644
index 000000000..fb3ac9898
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/simple_warning.go
@@ -0,0 +1,25 @@
+package tfdiags
+
+type simpleWarning string
+
+var _ Diagnostic = simpleWarning("")
+
+// SimpleWarning constructs a simple (summary-only) warning diagnostic.
+func SimpleWarning(msg string) Diagnostic {
+	return simpleWarning(msg)
+}
+
+func (e simpleWarning) Severity() Severity {
+	return Warning
+}
+
+func (e simpleWarning) Description() Description {
+	return Description{
+		Summary: string(e),
+	}
+}
+
+func (e simpleWarning) Source() Source {
+	// No source information available for a native error
+	return Source{}
+}
diff --git a/vendor/github.com/hashicorp/terraform/tfdiags/source_range.go b/vendor/github.com/hashicorp/terraform/tfdiags/source_range.go
new file mode 100644
index 000000000..3031168d6
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/tfdiags/source_range.go
@@ -0,0 +1,35 @@
+package tfdiags
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+)
+
+type SourceRange struct {
+	Filename   string
+	Start, End SourcePos
+}
+
+type SourcePos struct {
+	Line, Column, Byte int
+}
+
+// StartString returns a string representation of the start of the range,
+// including the filename and the line and column numbers.
+func (r SourceRange) StartString() string {
+	filename := r.Filename
+
+	// We'll try to relative-ize our filename here so it's less verbose
+	// in the common case of being in the current working directory. If not,
+	// we'll just show the full path.
+	wd, err := os.Getwd()
+	if err == nil {
+		relFn, err := filepath.Rel(wd, filename)
+		if err == nil {
+			filename = relFn
+		}
+	}
+
+	return fmt.Sprintf("%s:%d,%d", filename, r.Start.Line, r.Start.Column)
+}
diff --git a/vendor/github.com/hashicorp/terraform/version/version.go b/vendor/github.com/hashicorp/terraform/version/version.go
new file mode 100644
index 000000000..e6ea9e743
--- /dev/null
+++ b/vendor/github.com/hashicorp/terraform/version/version.go
@@ -0,0 +1,36 @@
+// The version package provides a location to set the release versions for all
+// packages to consume, without creating import cycles.
+//
+// This pckage should not import any other terraform packages.
+package version
+
+import (
+	"fmt"
+
+	version "github.com/hashicorp/go-version"
+)
+
+// The main version number that is being run at the moment.
+const Version = "0.10.9"
+
+// A pre-release marker for the version. If this is "" (empty string)
+// then it means that it is a final release. Otherwise, this is a pre-release
+// such as "dev" (in development), "beta", "rc1", etc.
+var Prerelease = "dev"
+
+// SemVer is an instance of version.Version. This has the secondary
+// benefit of verifying during tests and init time that our version is a
+// proper semantic version, which should always be the case.
+var SemVer = version.Must(version.NewVersion(Version))
+
+// Header is the header name used to send the current terraform version
+// in http requests.
+const Header = "Terraform-Version"
+
+// String returns the complete version string, including prerelease
+func String() string {
+	if Prerelease != "" {
+		return fmt.Sprintf("%s-%s", Version, Prerelease)
+	}
+	return Version
+}
diff --git a/vendor/github.com/mitchellh/go-wordwrap/LICENSE.md b/vendor/github.com/mitchellh/go-wordwrap/LICENSE.md
new file mode 100644
index 000000000..229851590
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-wordwrap/LICENSE.md
@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) 2014 Mitchell Hashimoto
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.
diff --git a/vendor/github.com/mitchellh/go-wordwrap/README.md b/vendor/github.com/mitchellh/go-wordwrap/README.md
new file mode 100644
index 000000000..60ae31170
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-wordwrap/README.md
@@ -0,0 +1,39 @@
+# go-wordwrap
+
+`go-wordwrap` (Golang package: `wordwrap`) is a package for Go that
+automatically wraps words into multiple lines. The primary use case for this
+is in formatting CLI output, but of course word wrapping is a generally useful
+thing to do.
+
+## Installation and Usage
+
+Install using `go get github.com/mitchellh/go-wordwrap`.
+
+Full documentation is available at
+http://godoc.org/github.com/mitchellh/go-wordwrap
+
+Below is an example of its usage ignoring errors:
+
+```go
+wrapped := wordwrap.WrapString("foo bar baz", 3)
+fmt.Println(wrapped)
+```
+
+Would output:
+
+```
+foo
+bar
+baz
+```
+
+## Word Wrap Algorithm
+
+This library doesn't use any clever algorithm for word wrapping. The wrapping
+is actually very naive: whenever there is whitespace or an explicit linebreak.
+The goal of this library is for word wrapping CLI output, so the input is
+typically pretty well controlled human language. Because of this, the naive
+approach typically works just fine.
+
+In the future, we'd like to make the algorithm more advanced. We would do
+so without breaking the API.
diff --git a/vendor/github.com/mitchellh/go-wordwrap/wordwrap.go b/vendor/github.com/mitchellh/go-wordwrap/wordwrap.go
new file mode 100644
index 000000000..ac67205bc
--- /dev/null
+++ b/vendor/github.com/mitchellh/go-wordwrap/wordwrap.go
@@ -0,0 +1,73 @@
+package wordwrap
+
+import (
+	"bytes"
+	"unicode"
+)
+
+// WrapString wraps the given string within lim width in characters.
+//
+// Wrapping is currently naive and only happens at white-space. A future
+// version of the library will implement smarter wrapping. This means that
+// pathological cases can dramatically reach past the limit, such as a very
+// long word.
+func WrapString(s string, lim uint) string {
+	// Initialize a buffer with a slightly larger size to account for breaks
+	init := make([]byte, 0, len(s))
+	buf := bytes.NewBuffer(init)
+
+	var current uint
+	var wordBuf, spaceBuf bytes.Buffer
+
+	for _, char := range s {
+		if char == '\n' {
+			if wordBuf.Len() == 0 {
+				if current+uint(spaceBuf.Len()) > lim {
+					current = 0
+				} else {
+					current += uint(spaceBuf.Len())
+					spaceBuf.WriteTo(buf)
+				}
+				spaceBuf.Reset()
+			} else {
+				current += uint(spaceBuf.Len() + wordBuf.Len())
+				spaceBuf.WriteTo(buf)
+				spaceBuf.Reset()
+				wordBuf.WriteTo(buf)
+				wordBuf.Reset()
+			}
+			buf.WriteRune(char)
+			current = 0
+		} else if unicode.IsSpace(char) {
+			if spaceBuf.Len() == 0 || wordBuf.Len() > 0 {
+				current += uint(spaceBuf.Len() + wordBuf.Len())
+				spaceBuf.WriteTo(buf)
+				spaceBuf.Reset()
+				wordBuf.WriteTo(buf)
+				wordBuf.Reset()
+			}
+
+			spaceBuf.WriteRune(char)
+		} else {
+
+			wordBuf.WriteRune(char)
+
+			if current+uint(spaceBuf.Len()+wordBuf.Len()) > lim && uint(wordBuf.Len()) < lim {
+				buf.WriteRune('\n')
+				current = 0
+				spaceBuf.Reset()
+			}
+		}
+	}
+
+	if wordBuf.Len() == 0 {
+		if current+uint(spaceBuf.Len()) <= lim {
+			spaceBuf.WriteTo(buf)
+		}
+	} else {
+		spaceBuf.WriteTo(buf)
+		wordBuf.WriteTo(buf)
+	}
+
+	return buf.String()
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/capsule.go b/vendor/github.com/zclconf/go-cty/cty/capsule.go
new file mode 100644
index 000000000..4fce92add
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/capsule.go
@@ -0,0 +1,89 @@
+package cty
+
+import (
+	"fmt"
+	"reflect"
+)
+
+type capsuleType struct {
+	typeImplSigil
+	Name   string
+	GoType reflect.Type
+}
+
+func (t *capsuleType) Equals(other Type) bool {
+	if otherP, ok := other.typeImpl.(*capsuleType); ok {
+		// capsule types compare by pointer identity
+		return otherP == t
+	}
+	return false
+}
+
+func (t *capsuleType) FriendlyName() string {
+	return t.Name
+}
+
+func (t *capsuleType) GoString() string {
+	// To get a useful representation of our native type requires some
+	// shenanigans.
+	victimVal := reflect.Zero(t.GoType)
+	return fmt.Sprintf("cty.Capsule(%q, reflect.TypeOf(%#v))", t.Name, victimVal.Interface())
+}
+
+// Capsule creates a new Capsule type.
+//
+// A Capsule type is a special type that can be used to transport arbitrary
+// Go native values of a given type through the cty type system. A language
+// that uses cty as its type system might, for example, provide functions
+// that return capsule-typed values and then other functions that operate
+// on those values.
+//
+// From cty's perspective, Capsule types have a few interesting characteristics,
+// described in the following paragraphs.
+//
+// Each capsule type has an associated Go native type that it is able to
+// transport. Capsule types compare by identity, so each call to the
+// Capsule function creates an entirely-distinct cty Type, even if two calls
+// use the same native type.
+//
+// Each capsule-typed value contains a pointer to a value of the given native
+// type. A capsule-typed value supports no operations except equality, and
+// equality is implemented by pointer identity of the encapsulated pointer.
+//
+// The given name is used as the new type's "friendly name". This can be any
+// string in principle, but will usually be a short, all-lowercase name aimed
+// at users of the embedding language (i.e. not mention Go-specific details)
+// and will ideally not create ambiguity with any predefined cty type.
+//
+// Capsule types are never introduced by any standard cty operation, so a
+// calling application opts in to including them within its own type system
+// by creating them and introducing them via its own functions. At that point,
+// the application is responsible for dealing with any capsule-typed values
+// that might be returned.
+func Capsule(name string, nativeType reflect.Type) Type {
+	return Type{
+		&capsuleType{
+			Name:   name,
+			GoType: nativeType,
+		},
+	}
+}
+
+// IsCapsuleType returns true if this type is a capsule type, as created
+// by cty.Capsule .
+func (t Type) IsCapsuleType() bool {
+	_, ok := t.typeImpl.(*capsuleType)
+	return ok
+}
+
+// EncapsulatedType returns the encapsulated native type of a capsule type,
+// or panics if the receiver is not a Capsule type.
+//
+// Is IsCapsuleType to determine if this method is safe to call.
+func (t Type) EncapsulatedType() reflect.Type {
+	impl, ok := t.typeImpl.(*capsuleType)
+	if !ok {
+		panic("not a capsule type")
+	}
+	return impl.GoType
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/collection.go b/vendor/github.com/zclconf/go-cty/cty/collection.go
new file mode 100644
index 000000000..ab3919b14
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/collection.go
@@ -0,0 +1,34 @@
+package cty
+
+import (
+	"errors"
+)
+
+type collectionTypeImpl interface {
+	ElementType() Type
+}
+
+// IsCollectionType returns true if the given type supports the operations
+// that are defined for all collection types.
+func (t Type) IsCollectionType() bool {
+	_, ok := t.typeImpl.(collectionTypeImpl)
+	return ok
+}
+
+// ElementType returns the element type of the receiver if it is a collection
+// type, or panics if it is not. Use IsCollectionType first to test whether
+// this method will succeed.
+func (t Type) ElementType() Type {
+	if ct, ok := t.typeImpl.(collectionTypeImpl); ok {
+		return ct.ElementType()
+	}
+	panic(errors.New("not a collection type"))
+}
+
+// ElementCallback is a callback type used for iterating over elements of
+// collections and attributes of objects.
+//
+// The types of key and value depend on what type is being iterated over.
+// Return true to stop iterating after the current element, or false to
+// continue iterating.
+type ElementCallback func(key Value, val Value) (stop bool)
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/compare_types.go b/vendor/github.com/zclconf/go-cty/cty/convert/compare_types.go
new file mode 100644
index 000000000..d84f6ac10
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/compare_types.go
@@ -0,0 +1,165 @@
+package convert
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// compareTypes implements a preference order for unification.
+//
+// The result of this method is not useful for anything other than unification
+// preferences, since it assumes that the caller will verify that any suggested
+// conversion is actually possible and it is thus able to to make certain
+// optimistic assumptions.
+func compareTypes(a cty.Type, b cty.Type) int {
+
+	// DynamicPseudoType always has lowest preference, because anything can
+	// convert to it (it acts as a placeholder for "any type") and we want
+	// to optimistically assume that any dynamics will converge on matching
+	// their neighbors.
+	if a == cty.DynamicPseudoType || b == cty.DynamicPseudoType {
+		if a != cty.DynamicPseudoType {
+			return -1
+		}
+		if b != cty.DynamicPseudoType {
+			return 1
+		}
+		return 0
+	}
+
+	if a.IsPrimitiveType() && b.IsPrimitiveType() {
+		// String is a supertype of all primitive types, because we can
+		// represent all primitive values as specially-formatted strings.
+		if a == cty.String || b == cty.String {
+			if a != cty.String {
+				return 1
+			}
+			if b != cty.String {
+				return -1
+			}
+			return 0
+		}
+	}
+
+	if a.IsListType() && b.IsListType() {
+		return compareTypes(a.ElementType(), b.ElementType())
+	}
+	if a.IsSetType() && b.IsSetType() {
+		return compareTypes(a.ElementType(), b.ElementType())
+	}
+	if a.IsMapType() && b.IsMapType() {
+		return compareTypes(a.ElementType(), b.ElementType())
+	}
+
+	// From this point on we may have swapped the two items in order to
+	// simplify our cases. Therefore any non-zero return after this point
+	// must be multiplied by "swap" to potentially invert the return value
+	// if needed.
+	swap := 1
+	switch {
+	case a.IsTupleType() && b.IsListType():
+		fallthrough
+	case a.IsObjectType() && b.IsMapType():
+		fallthrough
+	case a.IsSetType() && b.IsTupleType():
+		fallthrough
+	case a.IsSetType() && b.IsListType():
+		a, b = b, a
+		swap = -1
+	}
+
+	if b.IsSetType() && (a.IsTupleType() || a.IsListType()) {
+		// We'll just optimistically assume that the element types are
+		// unifyable/convertible, and let a second recursive pass
+		// figure out how to make that so.
+		return -1 * swap
+	}
+
+	if a.IsListType() && b.IsTupleType() {
+		// We'll just optimistically assume that the tuple's element types
+		// can be unified into something compatible with the list's element
+		// type.
+		return -1 * swap
+	}
+
+	if a.IsMapType() && b.IsObjectType() {
+		// We'll just optimistically assume that the object's attribute types
+		// can be unified into something compatible with the map's element
+		// type.
+		return -1 * swap
+	}
+
+	// For object and tuple types, comparing two types doesn't really tell
+	// the whole story because it may be possible to construct a new type C
+	// that is the supertype of both A and B by unifying each attribute/element
+	// separately. That possibility is handled by Unify as a follow-up if
+	// type sorting is insufficient to produce a valid result.
+	//
+	// Here we will take care of the simple possibilities where no new type
+	// is needed.
+	if a.IsObjectType() && b.IsObjectType() {
+		atysA := a.AttributeTypes()
+		atysB := b.AttributeTypes()
+
+		if len(atysA) != len(atysB) {
+			return 0
+		}
+
+		hasASuper := false
+		hasBSuper := false
+		for k := range atysA {
+			if _, has := atysB[k]; !has {
+				return 0
+			}
+
+			cmp := compareTypes(atysA[k], atysB[k])
+			if cmp < 0 {
+				hasASuper = true
+			} else if cmp > 0 {
+				hasBSuper = true
+			}
+		}
+
+		switch {
+		case hasASuper && hasBSuper:
+			return 0
+		case hasASuper:
+			return -1 * swap
+		case hasBSuper:
+			return 1 * swap
+		default:
+			return 0
+		}
+	}
+	if a.IsTupleType() && b.IsTupleType() {
+		etysA := a.TupleElementTypes()
+		etysB := b.TupleElementTypes()
+
+		if len(etysA) != len(etysB) {
+			return 0
+		}
+
+		hasASuper := false
+		hasBSuper := false
+		for i := range etysA {
+			cmp := compareTypes(etysA[i], etysB[i])
+			if cmp < 0 {
+				hasASuper = true
+			} else if cmp > 0 {
+				hasBSuper = true
+			}
+		}
+
+		switch {
+		case hasASuper && hasBSuper:
+			return 0
+		case hasASuper:
+			return -1 * swap
+		case hasBSuper:
+			return 1 * swap
+		default:
+			return 0
+		}
+	}
+
+	return 0
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go
new file mode 100644
index 000000000..b064bfb7d
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion.go
@@ -0,0 +1,99 @@
+package convert
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// conversion is an internal variant of Conversion that carries around
+// a cty.Path to be used in error responses.
+type conversion func(cty.Value, cty.Path) (cty.Value, error)
+
+func getConversion(in cty.Type, out cty.Type, unsafe bool) conversion {
+	conv := getConversionKnown(in, out, unsafe)
+	if conv == nil {
+		return nil
+	}
+
+	// Wrap the conversion in some standard checks that we don't want to
+	// have to repeat in every conversion function.
+	return func(in cty.Value, path cty.Path) (cty.Value, error) {
+		if !in.IsKnown() {
+			return cty.UnknownVal(out), nil
+		}
+		if in.IsNull() {
+			// We'll pass through nulls, albeit type converted, and let
+			// the caller deal with whatever handling they want to do in
+			// case null values are considered valid in some applications.
+			return cty.NullVal(out), nil
+		}
+
+		return conv(in, path)
+	}
+}
+
+func getConversionKnown(in cty.Type, out cty.Type, unsafe bool) conversion {
+	switch {
+
+	case out == cty.DynamicPseudoType:
+		// Conversion *to* DynamicPseudoType means that the caller wishes
+		// to allow any type in this position, so we'll produce a do-nothing
+		// conversion that just passes through the value as-is.
+		return dynamicPassthrough
+
+	case unsafe && in == cty.DynamicPseudoType:
+		// Conversion *from* DynamicPseudoType means that we have a value
+		// whose type isn't yet known during type checking. For these we will
+		// assume that conversion will succeed and deal with any errors that
+		// result (which is why we can only do this when "unsafe" is set).
+		return dynamicFixup(out)
+
+	case in.IsPrimitiveType() && out.IsPrimitiveType():
+		conv := primitiveConversionsSafe[in][out]
+		if conv != nil {
+			return conv
+		}
+		if unsafe {
+			return primitiveConversionsUnsafe[in][out]
+		}
+		return nil
+
+	case out.IsListType() && (in.IsListType() || in.IsSetType()):
+		inEty := in.ElementType()
+		outEty := out.ElementType()
+		if inEty.Equals(outEty) {
+			// This indicates that we're converting from list to set with
+			// the same element type, so we don't need an element converter.
+			return conversionCollectionToList(outEty, nil)
+		}
+
+		convEty := getConversion(inEty, outEty, unsafe)
+		if convEty == nil {
+			return nil
+		}
+		return conversionCollectionToList(outEty, convEty)
+
+	case out.IsListType() && in.IsTupleType():
+		outEty := out.ElementType()
+		return conversionTupleToList(in, outEty, unsafe)
+
+	case out.IsMapType() && in.IsObjectType():
+		outEty := out.ElementType()
+		return conversionObjectToMap(in, outEty, unsafe)
+
+	default:
+		return nil
+
+	}
+}
+
+// retConversion wraps a conversion (internal type) so it can be returned
+// as a Conversion (public type).
+func retConversion(conv conversion) Conversion {
+	if conv == nil {
+		return nil
+	}
+
+	return func(in cty.Value) (cty.Value, error) {
+		return conv(in, cty.Path(nil))
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go
new file mode 100644
index 000000000..a6a4c35d7
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_collection.go
@@ -0,0 +1,186 @@
+package convert
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// conversionCollectionToList returns a conversion that will apply the given
+// conversion to all of the elements of a collection (something that supports
+// ForEachElement and LengthInt) and then returns the result as a list.
+//
+// "conv" can be nil if the elements are expected to already be of the
+// correct type and just need to be re-wrapped into a list. (For example,
+// if we're converting from a set into a list of the same element type.)
+func conversionCollectionToList(ety cty.Type, conv conversion) conversion {
+	return func(val cty.Value, path cty.Path) (cty.Value, error) {
+		elems := make([]cty.Value, 0, val.LengthInt())
+		i := int64(0)
+		path = append(path, nil)
+		it := val.ElementIterator()
+		for it.Next() {
+			_, val := it.Element()
+			var err error
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(i),
+			}
+
+			if conv != nil {
+				val, err = conv(val, path)
+				if err != nil {
+					return cty.NilVal, err
+				}
+			}
+			elems = append(elems, val)
+
+			i++
+		}
+
+		if len(elems) == 0 {
+			return cty.ListValEmpty(ety), nil
+		}
+
+		return cty.ListVal(elems), nil
+	}
+}
+
+// conversionTupleToList returns a conversion that will take a value of the
+// given tuple type and return a list of the given element type.
+//
+// Will panic if the given tupleType isn't actually a tuple type.
+func conversionTupleToList(tupleType cty.Type, listEty cty.Type, unsafe bool) conversion {
+	tupleEtys := tupleType.TupleElementTypes()
+
+	if len(tupleEtys) == 0 {
+		// Empty tuple short-circuit
+		return func(val cty.Value, path cty.Path) (cty.Value, error) {
+			return cty.ListValEmpty(listEty), nil
+		}
+	}
+
+	if listEty == cty.DynamicPseudoType {
+		// This is a special case where the caller wants us to find
+		// a suitable single type that all elements can convert to, if
+		// possible.
+		listEty, _ = unify(tupleEtys, unsafe)
+		if listEty == cty.NilType {
+			return nil
+		}
+	}
+
+	elemConvs := make([]conversion, len(tupleEtys))
+	for i, tupleEty := range tupleEtys {
+		if tupleEty.Equals(listEty) {
+			// no conversion required
+			continue
+		}
+
+		elemConvs[i] = getConversion(tupleEty, listEty, unsafe)
+		if elemConvs[i] == nil {
+			// If any of our element conversions are impossible, then the our
+			// whole conversion is impossible.
+			return nil
+		}
+	}
+
+	// If we fall out here then a conversion is possible, using the
+	// element conversions in elemConvs
+	return func(val cty.Value, path cty.Path) (cty.Value, error) {
+		elems := make([]cty.Value, 0, len(elemConvs))
+		path = append(path, nil)
+		i := int64(0)
+		it := val.ElementIterator()
+		for it.Next() {
+			_, val := it.Element()
+			var err error
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(i),
+			}
+
+			conv := elemConvs[i]
+			if conv != nil {
+				val, err = conv(val, path)
+				if err != nil {
+					return cty.NilVal, err
+				}
+			}
+			elems = append(elems, val)
+
+			i++
+		}
+
+		return cty.ListVal(elems), nil
+	}
+}
+
+// conversionObjectToMap returns a conversion that will take a value of the
+// given object type and return a map of the given element type.
+//
+// Will panic if the given objectType isn't actually an object type.
+func conversionObjectToMap(objectType cty.Type, mapEty cty.Type, unsafe bool) conversion {
+	objectAtys := objectType.AttributeTypes()
+
+	if len(objectAtys) == 0 {
+		// Empty object short-circuit
+		return func(val cty.Value, path cty.Path) (cty.Value, error) {
+			return cty.MapValEmpty(mapEty), nil
+		}
+	}
+
+	if mapEty == cty.DynamicPseudoType {
+		// This is a special case where the caller wants us to find
+		// a suitable single type that all elements can convert to, if
+		// possible.
+		objectAtysList := make([]cty.Type, 0, len(objectAtys))
+		for _, aty := range objectAtys {
+			objectAtysList = append(objectAtysList, aty)
+		}
+		mapEty, _ = unify(objectAtysList, unsafe)
+		if mapEty == cty.NilType {
+			return nil
+		}
+	}
+
+	elemConvs := make(map[string]conversion, len(objectAtys))
+	for name, objectAty := range objectAtys {
+		if objectAty.Equals(mapEty) {
+			// no conversion required
+			continue
+		}
+
+		elemConvs[name] = getConversion(objectAty, mapEty, unsafe)
+		if elemConvs[name] == nil {
+			// If any of our element conversions are impossible, then the our
+			// whole conversion is impossible.
+			return nil
+		}
+	}
+
+	// If we fall out here then a conversion is possible, using the
+	// element conversions in elemConvs
+	return func(val cty.Value, path cty.Path) (cty.Value, error) {
+		elems := make(map[string]cty.Value, len(elemConvs))
+		path = append(path, nil)
+		it := val.ElementIterator()
+		for it.Next() {
+			name, val := it.Element()
+			var err error
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: name,
+			}
+
+			conv := elemConvs[name.AsString()]
+			if conv != nil {
+				val, err = conv(val, path)
+				if err != nil {
+					return cty.NilVal, err
+				}
+			}
+			elems[name.AsString()] = val
+		}
+
+		return cty.MapVal(elems), nil
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_dynamic.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_dynamic.go
new file mode 100644
index 000000000..4d19cf6c5
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_dynamic.go
@@ -0,0 +1,33 @@
+package convert
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// dynamicFixup deals with just-in-time conversions of values that were
+// input-typed as cty.DynamicPseudoType during analysis, ensuring that
+// we end up with the desired output type once the value is known, or
+// failing with an error if that is not possible.
+//
+// This is in the spirit of the cty philosophy of optimistically assuming that
+// DynamicPseudoType values will become the intended value eventually, and
+// dealing with any inconsistencies during final evaluation.
+func dynamicFixup(wantType cty.Type) conversion {
+	return func(in cty.Value, path cty.Path) (cty.Value, error) {
+		ret, err := Convert(in, wantType)
+		if err != nil {
+			// Re-wrap this error so that the returned path is relative
+			// to the caller's original value, rather than relative to our
+			// conversion value here.
+			return cty.NilVal, path.NewError(err)
+		}
+		return ret, nil
+	}
+}
+
+// dynamicPassthrough is an identity conversion that is used when the
+// target type is DynamicPseudoType, indicating that the caller doesn't care
+// which type is returned.
+func dynamicPassthrough(in cty.Value, path cty.Path) (cty.Value, error) {
+	return in, nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/conversion_primitive.go b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_primitive.go
new file mode 100644
index 000000000..399ff9a59
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/conversion_primitive.go
@@ -0,0 +1,50 @@
+package convert
+
+import (
+	"math/big"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+var stringTrue = cty.StringVal("true")
+var stringFalse = cty.StringVal("false")
+
+var primitiveConversionsSafe = map[cty.Type]map[cty.Type]conversion{
+	cty.Number: {
+		cty.String: func(val cty.Value, path cty.Path) (cty.Value, error) {
+			f := val.AsBigFloat()
+			return cty.StringVal(f.Text('f', -1)), nil
+		},
+	},
+	cty.Bool: {
+		cty.String: func(val cty.Value, path cty.Path) (cty.Value, error) {
+			if val.True() {
+				return stringTrue, nil
+			} else {
+				return stringFalse, nil
+			}
+		},
+	},
+}
+
+var primitiveConversionsUnsafe = map[cty.Type]map[cty.Type]conversion{
+	cty.String: {
+		cty.Number: func(val cty.Value, path cty.Path) (cty.Value, error) {
+			f, _, err := (&big.Float{}).Parse(val.AsString(), 10)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("a number is required")
+			}
+			return cty.NumberVal(f), nil
+		},
+		cty.Bool: func(val cty.Value, path cty.Path) (cty.Value, error) {
+			switch val.AsString() {
+			case "true", "1":
+				return cty.True, nil
+			case "false", "0":
+				return cty.False, nil
+			default:
+				return cty.NilVal, path.NewErrorf("a bool is required")
+			}
+		},
+	},
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/doc.go b/vendor/github.com/zclconf/go-cty/cty/convert/doc.go
new file mode 100644
index 000000000..2037299ba
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/doc.go
@@ -0,0 +1,15 @@
+// Package convert contains some routines for converting between cty types.
+// The intent of providing this package is to encourage applications using
+// cty to have consistent type conversion behavior for maximal interoperability
+// when Values pass from one application to another.
+//
+// The conversions are categorized into two categories. "Safe" conversions are
+// ones that are guaranteed to succeed if given a non-null value of the
+// appropriate source type. "Unsafe" conversions, on the other hand, are valid
+// for only a subset of input values, and thus may fail with an error when
+// called for values outside of that valid subset.
+//
+// The functions whose names end in Unsafe support all of the conversions that
+// are supported by the corresponding functions whose names do not have that
+// suffix, and then additional unsafe conversions as well.
+package convert
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/public.go b/vendor/github.com/zclconf/go-cty/cty/convert/public.go
new file mode 100644
index 000000000..55f44aeca
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/public.go
@@ -0,0 +1,83 @@
+package convert
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+// This file contains the public interface of this package, which is intended
+// to be a small, convenient interface designed for easy integration into
+// a hypothetical language type checker and interpreter.
+
+// Conversion is a named function type representing a conversion from a
+// value of one type to a value of another type.
+//
+// The source type for a conversion is always the source type given to
+// the function that returned the Conversion, but there is no way to recover
+// that from a Conversion value itself. If a Conversion is given a value
+// that is not of its expected type (with the exception of DynamicPseudoType,
+// which is always supported) then the function may panic or produce undefined
+// results.
+type Conversion func(in cty.Value) (out cty.Value, err error)
+
+// GetConversion returns a Conversion between the given in and out Types if
+// a safe one is available, or returns nil otherwise.
+func GetConversion(in cty.Type, out cty.Type) Conversion {
+	return retConversion(getConversion(in, out, false))
+}
+
+// GetConversionUnsafe returns a Conversion between the given in and out Types
+// if either a safe or unsafe one is available, or returns nil otherwise.
+func GetConversionUnsafe(in cty.Type, out cty.Type) Conversion {
+	return retConversion(getConversion(in, out, true))
+}
+
+// Convert returns the result of converting the given value to the given type
+// if an safe or unsafe conversion is available, or returns an error if such a
+// conversion is impossible.
+//
+// This is a convenience wrapper around calling GetConversionUnsafe and then
+// immediately passing the given value to the resulting function.
+func Convert(in cty.Value, want cty.Type) (cty.Value, error) {
+	if in.Type().Equals(want) {
+		return in, nil
+	}
+
+	conv := GetConversionUnsafe(in.Type(), want)
+	if conv == nil {
+		return cty.NilVal, fmt.Errorf("incorrect type; %s required", want.FriendlyName())
+	}
+	return conv(in)
+}
+
+// Unify attempts to find the most general type that can be converted from
+// all of the given types. If this is possible, that type is returned along
+// with a slice of necessary conversions for some of the given types.
+//
+// If no common supertype can be found, this function returns cty.NilType and
+// a nil slice.
+//
+// If a common supertype *can* be found, the returned slice will always be
+// non-nil and will contain a non-nil conversion for each given type that
+// needs to be converted, with indices corresponding to the input slice.
+// Any given type that does *not* need conversion (because it is already of
+// the appropriate type) will have a nil Conversion.
+//
+// cty.DynamicPseudoType is, as usual, a special case. If the given type list
+// contains a mixture of dynamic and non-dynamic types, the dynamic types are
+// disregarded for type selection and a conversion is returned for them that
+// will attempt a late conversion of the given value to the target type,
+// failing with a conversion error if the eventual concrete type is not
+// compatible. If *all* given types are DynamicPseudoType, or in the
+// degenerate case of an empty slice of types, the returned type is itself
+// cty.DynamicPseudoType and no conversions are attempted.
+func Unify(types []cty.Type) (cty.Type, []Conversion) {
+	return unify(types, false)
+}
+
+// UnifyUnsafe is the same as Unify except that it may return unsafe
+// conversions in situations where a safe conversion isn't also available.
+func UnifyUnsafe(types []cty.Type) (cty.Type, []Conversion) {
+	return unify(types, true)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/sort_types.go b/vendor/github.com/zclconf/go-cty/cty/convert/sort_types.go
new file mode 100644
index 000000000..b7769106d
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/sort_types.go
@@ -0,0 +1,69 @@
+package convert
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// sortTypes produces an ordering of the given types that serves as a
+// preference order for the result of unification of the given types.
+// The return value is a slice of indices into the given slice, and will
+// thus always be the same length as the given slice.
+//
+// The goal is that the most general of the given types will appear first
+// in the ordering. If there are uncomparable pairs of types in the list
+// then they will appear in an undefined order, and the unification pass
+// will presumably then fail.
+func sortTypes(tys []cty.Type) []int {
+	l := len(tys)
+
+	// First we build a graph whose edges represent "more general than",
+	// which we will then do a topological sort of.
+	edges := make([][]int, l)
+	for i := 0; i < (l - 1); i++ {
+		for j := i + 1; j < l; j++ {
+			cmp := compareTypes(tys[i], tys[j])
+			switch {
+			case cmp < 0:
+				edges[i] = append(edges[i], j)
+			case cmp > 0:
+				edges[j] = append(edges[j], i)
+			}
+		}
+	}
+
+	// Compute the in-degree of each node
+	inDegree := make([]int, l)
+	for _, outs := range edges {
+		for _, j := range outs {
+			inDegree[j]++
+		}
+	}
+
+	// The array backing our result will double as our queue for visiting
+	// the nodes, with the queue slice moving along this array until it
+	// is empty and positioned at the end of the array. Thus our visiting
+	// order is also our result order.
+	result := make([]int, l)
+	queue := result[0:0]
+
+	// Initialize the queue with any item of in-degree 0, preserving
+	// their relative order.
+	for i, n := range inDegree {
+		if n == 0 {
+			queue = append(queue, i)
+		}
+	}
+
+	for len(queue) != 0 {
+		i := queue[0]
+		queue = queue[1:]
+		for _, j := range edges[i] {
+			inDegree[j]--
+			if inDegree[j] == 0 {
+				queue = append(queue, j)
+			}
+		}
+	}
+
+	return result
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/convert/unify.go b/vendor/github.com/zclconf/go-cty/cty/convert/unify.go
new file mode 100644
index 000000000..bd6736b4d
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/convert/unify.go
@@ -0,0 +1,66 @@
+package convert
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// The current unify implementation is somewhat inefficient, but we accept this
+// under the assumption that it will generally be used with small numbers of
+// types and with types of reasonable complexity. However, it does have a
+// "happy path" where all of the given types are equal.
+//
+// This function is likely to have poor performance in cases where any given
+// types are very complex (lots of deeply-nested structures) or if the list
+// of types itself is very large. In particular, it will walk the nested type
+// structure under the given types several times, especially when given a
+// list of types for which unification is not possible, since each permutation
+// will be tried to determine that result.
+func unify(types []cty.Type, unsafe bool) (cty.Type, []Conversion) {
+	if len(types) == 0 {
+		// Degenerate case
+		return cty.NilType, nil
+	}
+
+	prefOrder := sortTypes(types)
+
+	// sortTypes gives us an order where earlier items are preferable as
+	// our result type. We'll now walk through these and choose the first
+	// one we encounter for which conversions exist for all source types.
+	conversions := make([]Conversion, len(types))
+Preferences:
+	for _, wantTypeIdx := range prefOrder {
+		wantType := types[wantTypeIdx]
+		for i, tryType := range types {
+			if i == wantTypeIdx {
+				// Don't need to convert our wanted type to itself
+				conversions[i] = nil
+				continue
+			}
+
+			if tryType.Equals(wantType) {
+				conversions[i] = nil
+				continue
+			}
+
+			if unsafe {
+				conversions[i] = GetConversionUnsafe(tryType, wantType)
+			} else {
+				conversions[i] = GetConversion(tryType, wantType)
+			}
+
+			if conversions[i] == nil {
+				// wantType is not a suitable unification type, so we'll
+				// try the next one in our preference order.
+				continue Preferences
+			}
+		}
+
+		return wantType, conversions
+	}
+
+	// TODO: For structural types, try to invent a new type that they
+	// can all be unified to, by unifying their respective attributes.
+
+	// If we fall out here, no unification is possible
+	return cty.NilType, nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/doc.go b/vendor/github.com/zclconf/go-cty/cty/doc.go
new file mode 100644
index 000000000..d31f0547b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/doc.go
@@ -0,0 +1,18 @@
+// Package cty (pronounced see-tie) provides some infrastructure for a type
+// system that might be useful for applications that need to represent
+// configuration values provided by the user whose types are not known
+// at compile time, particularly if the calling application also allows
+// such values to be used in expressions.
+//
+// The type system consists of primitive types Number, String and Bool, as
+// well as List and Map collection types and Object types that can have
+// arbitrarily-typed sets of attributes.
+//
+// A set of operations is defined on these types, which is accessible via
+// the wrapper struct Value, which annotates the raw, internal representation
+// of a value with its corresponding type.
+//
+// This package is oriented towards being a building block for configuration
+// languages used to bootstrap an application. It is not optimized for use
+// in tight loops where CPU time or memory pressure are a concern.
+package cty
diff --git a/vendor/github.com/zclconf/go-cty/cty/element_iterator.go b/vendor/github.com/zclconf/go-cty/cty/element_iterator.go
new file mode 100644
index 000000000..0bf84c774
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/element_iterator.go
@@ -0,0 +1,191 @@
+package cty
+
+import (
+	"sort"
+
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+// ElementIterator is the interface type returned by Value.ElementIterator to
+// allow the caller to iterate over elements of a collection-typed value.
+//
+// Its usage pattern is as follows:
+//
+//     it := val.ElementIterator()
+//     for it.Next() {
+//         key, val := it.Element()
+//         // ...
+//     }
+type ElementIterator interface {
+	Next() bool
+	Element() (key Value, value Value)
+}
+
+func canElementIterator(val Value) bool {
+	switch {
+	case val.ty.IsListType():
+		return true
+	case val.ty.IsMapType():
+		return true
+	case val.ty.IsSetType():
+		return true
+	case val.ty.IsTupleType():
+		return true
+	case val.ty.IsObjectType():
+		return true
+	default:
+		return false
+	}
+}
+
+func elementIterator(val Value) ElementIterator {
+	switch {
+	case val.ty.IsListType():
+		return &listElementIterator{
+			ety:  val.ty.ElementType(),
+			vals: val.v.([]interface{}),
+			idx:  -1,
+		}
+	case val.ty.IsMapType():
+		// We iterate the keys in a predictable lexicographical order so
+		// that results will always be stable given the same input map.
+		rawMap := val.v.(map[string]interface{})
+		keys := make([]string, 0, len(rawMap))
+		for key := range rawMap {
+			keys = append(keys, key)
+		}
+		sort.Strings(keys)
+
+		return &mapElementIterator{
+			ety:  val.ty.ElementType(),
+			vals: rawMap,
+			keys: keys,
+			idx:  -1,
+		}
+	case val.ty.IsSetType():
+		rawSet := val.v.(set.Set)
+		return &setElementIterator{
+			ety:   val.ty.ElementType(),
+			setIt: rawSet.Iterator(),
+		}
+	case val.ty.IsTupleType():
+		return &tupleElementIterator{
+			etys: val.ty.TupleElementTypes(),
+			vals: val.v.([]interface{}),
+			idx:  -1,
+		}
+	case val.ty.IsObjectType():
+		// We iterate the keys in a predictable lexicographical order so
+		// that results will always be stable given the same object type.
+		atys := val.ty.AttributeTypes()
+		keys := make([]string, 0, len(atys))
+		for key := range atys {
+			keys = append(keys, key)
+		}
+		sort.Strings(keys)
+
+		return &objectElementIterator{
+			atys:      atys,
+			vals:      val.v.(map[string]interface{}),
+			attrNames: keys,
+			idx:       -1,
+		}
+	default:
+		panic("attempt to iterate on non-collection, non-tuple type")
+	}
+}
+
+type listElementIterator struct {
+	ety  Type
+	vals []interface{}
+	idx  int
+}
+
+func (it *listElementIterator) Element() (Value, Value) {
+	i := it.idx
+	return NumberIntVal(int64(i)), Value{
+		ty: it.ety,
+		v:  it.vals[i],
+	}
+}
+
+func (it *listElementIterator) Next() bool {
+	it.idx++
+	return it.idx < len(it.vals)
+}
+
+type mapElementIterator struct {
+	ety  Type
+	vals map[string]interface{}
+	keys []string
+	idx  int
+}
+
+func (it *mapElementIterator) Element() (Value, Value) {
+	key := it.keys[it.idx]
+	return StringVal(key), Value{
+		ty: it.ety,
+		v:  it.vals[key],
+	}
+}
+
+func (it *mapElementIterator) Next() bool {
+	it.idx++
+	return it.idx < len(it.keys)
+}
+
+type setElementIterator struct {
+	ety   Type
+	setIt *set.Iterator
+}
+
+func (it *setElementIterator) Element() (Value, Value) {
+	val := Value{
+		ty: it.ety,
+		v:  it.setIt.Value(),
+	}
+	return val, val
+}
+
+func (it *setElementIterator) Next() bool {
+	return it.setIt.Next()
+}
+
+type tupleElementIterator struct {
+	etys []Type
+	vals []interface{}
+	idx  int
+}
+
+func (it *tupleElementIterator) Element() (Value, Value) {
+	i := it.idx
+	return NumberIntVal(int64(i)), Value{
+		ty: it.etys[i],
+		v:  it.vals[i],
+	}
+}
+
+func (it *tupleElementIterator) Next() bool {
+	it.idx++
+	return it.idx < len(it.vals)
+}
+
+type objectElementIterator struct {
+	atys      map[string]Type
+	vals      map[string]interface{}
+	attrNames []string
+	idx       int
+}
+
+func (it *objectElementIterator) Element() (Value, Value) {
+	key := it.attrNames[it.idx]
+	return StringVal(key), Value{
+		ty: it.atys[key],
+		v:  it.vals[key],
+	}
+}
+
+func (it *objectElementIterator) Next() bool {
+	it.idx++
+	return it.idx < len(it.attrNames)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/error.go b/vendor/github.com/zclconf/go-cty/cty/error.go
new file mode 100644
index 000000000..dd139f724
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/error.go
@@ -0,0 +1,55 @@
+package cty
+
+import (
+	"fmt"
+)
+
+// PathError is a specialization of error that represents where in a
+// potentially-deep data structure an error occured, using a Path.
+type PathError struct {
+	error
+	Path Path
+}
+
+func errorf(path Path, f string, args ...interface{}) error {
+	// We need to copy the Path because often our caller builds it by
+	// continually mutating the same underlying buffer.
+	sPath := make(Path, len(path))
+	copy(sPath, path)
+	return PathError{
+		error: fmt.Errorf(f, args...),
+		Path:  sPath,
+	}
+}
+
+// NewErrorf creates a new PathError for the current path by passing the
+// given format and arguments to fmt.Errorf and then wrapping the result
+// similarly to NewError.
+func (p Path) NewErrorf(f string, args ...interface{}) error {
+	return errorf(p, f, args...)
+}
+
+// NewError creates a new PathError for the current path, wrapping the given
+// error.
+func (p Path) NewError(err error) error {
+	// if we're being asked to wrap an existing PathError then our new
+	// PathError will be the concatenation of the two paths, ensuring
+	// that we still get a single flat PathError that's thus easier for
+	// callers to deal with.
+	perr, wrappingPath := err.(PathError)
+	pathLen := len(p)
+	if wrappingPath {
+		pathLen = pathLen + len(perr.Path)
+	}
+
+	sPath := make(Path, pathLen)
+	copy(sPath, p)
+	if wrappingPath {
+		copy(sPath[len(p):], perr.Path)
+	}
+
+	return PathError{
+		error: err,
+		Path:  sPath,
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/argument.go b/vendor/github.com/zclconf/go-cty/cty/function/argument.go
new file mode 100644
index 000000000..bfd30157e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/argument.go
@@ -0,0 +1,50 @@
+package function
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// Parameter represents a parameter to a function.
+type Parameter struct {
+	// Name is an optional name for the argument. This package ignores this
+	// value, but callers may use it for documentation, etc.
+	Name string
+
+	// A type that any argument for this parameter must conform to.
+	// cty.DynamicPseudoType can be used, either at top-level or nested
+	// in a parameterized type, to indicate that any type should be
+	// permitted, to allow the definition of type-generic functions.
+	Type cty.Type
+
+	// If AllowNull is set then null values may be passed into this
+	// argument's slot in both the type-check function and the implementation
+	// function. If not set, such values are rejected by the built-in
+	// checking rules.
+	AllowNull bool
+
+	// If AllowUnknown is set then unknown values may be passed into this
+	// argument's slot in the implementation function. If not set, any
+	// unknown values will cause the function to immediately return
+	// an unkonwn value without calling the implementation function, thus
+	// freeing the function implementer from dealing with this case.
+	AllowUnknown bool
+
+	// If AllowDynamicType is set then DynamicVal may be passed into this
+	// argument's slot in the implementation function. If not set, any
+	// dynamic values will cause the function to immediately return
+	// DynamicVal value without calling the implementation function, thus
+	// freeing the function implementer from dealing with this case.
+	//
+	// Note that DynamicVal is also unknown, so in order to receive dynamic
+	// *values* it is also necessary to set AllowUnknown.
+	//
+	// However, it is valid to set AllowDynamicType without AllowUnknown, in
+	// which case a dynamic value may be passed to the type checking function
+	// but will not make it to the *implementation* function. Instead, an
+	// unknown value of the type returned by the type-check function will be
+	// returned. This is suggested for functions that have a static return
+	// type since it allows the return value to be typed even if the input
+	// values are not, thus improving the type-check accuracy of derived
+	// values.
+	AllowDynamicType bool
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/doc.go b/vendor/github.com/zclconf/go-cty/cty/function/doc.go
new file mode 100644
index 000000000..ac1dd8ce7
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/doc.go
@@ -0,0 +1,6 @@
+// Package function builds on the functionality of cty by modeling functions
+// that operate on cty Values.
+//
+// Functions are, at their call, Go anonymous functions. However, this package
+// wraps around them utility functions for parameter type checking, etc.
+package function
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/error.go b/vendor/github.com/zclconf/go-cty/cty/function/error.go
new file mode 100644
index 000000000..2b5677998
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/error.go
@@ -0,0 +1,50 @@
+package function
+
+import (
+	"fmt"
+	"runtime/debug"
+)
+
+// ArgError represents an error with one of the arguments in a call. The
+// attribute Index represents the zero-based index of the argument in question.
+//
+// Its error *may* be a cty.PathError, in which case the error actually
+// pertains to a nested value within the data structure passed as the argument.
+type ArgError struct {
+	error
+	Index int
+}
+
+func NewArgErrorf(i int, f string, args ...interface{}) error {
+	return ArgError{
+		error: fmt.Errorf(f, args...),
+		Index: i,
+	}
+}
+
+func NewArgError(i int, err error) error {
+	return ArgError{
+		error: err,
+		Index: i,
+	}
+}
+
+// PanicError indicates that a panic occurred while executing either a
+// function's type or implementation function. This is captured and wrapped
+// into a normal error so that callers (expected to be language runtimes)
+// are freed from having to deal with panics in buggy functions.
+type PanicError struct {
+	Value interface{}
+	Stack []byte
+}
+
+func errorForPanic(val interface{}) error {
+	return PanicError{
+		Value: val,
+		Stack: debug.Stack(),
+	}
+}
+
+func (e PanicError) Error() string {
+	return fmt.Sprintf("panic in function implementation: %s\n%s", e.Value, e.Stack)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/function.go b/vendor/github.com/zclconf/go-cty/cty/function/function.go
new file mode 100644
index 000000000..162f7bfcd
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/function.go
@@ -0,0 +1,291 @@
+package function
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+// Function represents a function. This is the main type in this package.
+type Function struct {
+	spec *Spec
+}
+
+// Spec is the specification of a function, used to instantiate
+// a new Function.
+type Spec struct {
+	// Params is a description of the positional parameters for the function.
+	// The standard checking logic rejects any calls that do not provide
+	// arguments conforming to this definition, freeing the function
+	// implementer from dealing with such inconsistencies.
+	Params []Parameter
+
+	// VarParam is an optional specification of additional "varargs" the
+	// function accepts. If this is non-nil then callers may provide an
+	// arbitrary number of additional arguments (after those matching with
+	// the fixed parameters in Params) that conform to the given specification,
+	// which will appear as additional values in the slices of values
+	// provided to the type and implementation functions.
+	VarParam *Parameter
+
+	// Type is the TypeFunc that decides the return type of the function
+	// given its arguments, which may be Unknown. See the documentation
+	// of TypeFunc for more information.
+	//
+	// Use StaticReturnType if the function's return type does not vary
+	// depending on its arguments.
+	Type TypeFunc
+
+	// Impl is the ImplFunc that implements the function's behavior.
+	//
+	// Functions are expected to behave as pure functions, and not create
+	// any visible side-effects.
+	//
+	// If a TypeFunc is also provided, the value returned from Impl *must*
+	// conform to the type it returns, or a call to the function will panic.
+	Impl ImplFunc
+}
+
+// New creates a new function with the given specification.
+//
+// After passing a Spec to this function, the caller must no longer read from
+// or mutate it.
+func New(spec *Spec) Function {
+	f := Function{
+		spec: spec,
+	}
+	return f
+}
+
+// TypeFunc is a callback type for determining the return type of a function
+// given its arguments.
+//
+// Any of the values passed to this function may be unknown, even if the
+// parameters are not configured to accept unknowns.
+//
+// If any of the given values are *not* unknown, the TypeFunc may use the
+// values for pre-validation and for choosing the return type. For example,
+// a hypothetical JSON-unmarshalling function could return
+// cty.DynamicPseudoType if the given JSON string is unknown, but return
+// a concrete type based on the JSON structure if the JSON string is already
+// known.
+type TypeFunc func(args []cty.Value) (cty.Type, error)
+
+// ImplFunc is a callback type for the main implementation of a function.
+//
+// "args" are the values for the arguments, and this slice will always be at
+// least as long as the argument definition slice for the function.
+//
+// "retType" is the type returned from the Type callback, included as a
+// convenience to avoid the need to re-compute the return type for generic
+// functions whose return type is a function of the arguments.
+type ImplFunc func(args []cty.Value, retType cty.Type) (cty.Value, error)
+
+// StaticReturnType returns a TypeFunc that always returns the given type.
+//
+// This is provided as a convenience for defining a function whose return
+// type does not depend on the argument types.
+func StaticReturnType(ty cty.Type) TypeFunc {
+	return func([]cty.Value) (cty.Type, error) {
+		return ty, nil
+	}
+}
+
+// ReturnType returns the return type of a function given a set of candidate
+// argument types, or returns an error if the given types are unacceptable.
+//
+// If the caller already knows values for at least some of the arguments
+// it can be better to call ReturnTypeForValues, since certain functions may
+// determine their return types from their values and return DynamicVal if
+// the values are unknown.
+func (f Function) ReturnType(argTypes []cty.Type) (cty.Type, error) {
+	vals := make([]cty.Value, len(argTypes))
+	for i, ty := range argTypes {
+		vals[i] = cty.UnknownVal(ty)
+	}
+	return f.ReturnTypeForValues(vals)
+}
+
+// ReturnTypeForValues is similar to ReturnType but can be used if the caller
+// already knows the values of some or all of the arguments, in which case
+// the function may be able to determine a more definite result if its
+// return type depends on the argument *values*.
+//
+// For any arguments whose values are not known, pass an Unknown value of
+// the appropriate type.
+func (f Function) ReturnTypeForValues(args []cty.Value) (ty cty.Type, err error) {
+	var posArgs []cty.Value
+	var varArgs []cty.Value
+
+	if f.spec.VarParam == nil {
+		if len(args) != len(f.spec.Params) {
+			return cty.Type{}, fmt.Errorf(
+				"wrong number of arguments (%d required; %d given)",
+				len(f.spec.Params), len(args),
+			)
+		}
+
+		posArgs = args
+		varArgs = nil
+	} else {
+		if len(args) < len(f.spec.Params) {
+			return cty.Type{}, fmt.Errorf(
+				"wrong number of arguments (at least %d required; %d given)",
+				len(f.spec.Params), len(args),
+			)
+		}
+
+		posArgs = args[0:len(f.spec.Params)]
+		varArgs = args[len(f.spec.Params):]
+	}
+
+	for i, spec := range f.spec.Params {
+		val := posArgs[i]
+
+		if val.IsNull() && !spec.AllowNull {
+			return cty.Type{}, NewArgErrorf(i, "must not be null")
+		}
+
+		// AllowUnknown is ignored for type-checking, since we expect to be
+		// able to type check with unknown values. We *do* still need to deal
+		// with DynamicPseudoType here though, since the Type function might
+		// not be ready to deal with that.
+
+		if val.Type() == cty.DynamicPseudoType {
+			if !spec.AllowDynamicType {
+				return cty.DynamicPseudoType, nil
+			}
+		} else if errs := val.Type().TestConformance(spec.Type); errs != nil {
+			// For now we'll just return the first error in the set, since
+			// we don't have a good way to return the whole list here.
+			// Would be good to do something better at some point...
+			return cty.Type{}, NewArgError(i, errs[0])
+		}
+	}
+
+	if varArgs != nil {
+		spec := f.spec.VarParam
+		for i, val := range varArgs {
+			realI := i + len(posArgs)
+
+			if val.IsNull() && !spec.AllowNull {
+				return cty.Type{}, NewArgErrorf(realI, "must not be null")
+			}
+
+			if val.Type() == cty.DynamicPseudoType {
+				if !spec.AllowDynamicType {
+					return cty.DynamicPseudoType, nil
+				}
+			} else if errs := val.Type().TestConformance(spec.Type); errs != nil {
+				// For now we'll just return the first error in the set, since
+				// we don't have a good way to return the whole list here.
+				// Would be good to do something better at some point...
+				return cty.Type{}, NewArgError(i, errs[0])
+			}
+		}
+	}
+
+	// Intercept any panics from the function and return them as normal errors,
+	// so a calling language runtime doesn't need to deal with panics.
+	defer func() {
+		if r := recover(); r != nil {
+			ty = cty.NilType
+			err = errorForPanic(r)
+		}
+	}()
+
+	return f.spec.Type(args)
+}
+
+// Call actually calls the function with the given arguments, which must
+// conform to the function's parameter specification or an error will be
+// returned.
+func (f Function) Call(args []cty.Value) (val cty.Value, err error) {
+	expectedType, err := f.ReturnTypeForValues(args)
+	if err != nil {
+		return cty.NilVal, err
+	}
+
+	// Type checking already dealt with most situations relating to our
+	// parameter specification, but we still need to deal with unknown
+	// values.
+	posArgs := args[:len(f.spec.Params)]
+	varArgs := args[len(f.spec.Params):]
+
+	for i, spec := range f.spec.Params {
+		val := posArgs[i]
+
+		if !val.IsKnown() && !spec.AllowUnknown {
+			return cty.UnknownVal(expectedType), nil
+		}
+	}
+
+	if f.spec.VarParam != nil {
+		spec := f.spec.VarParam
+		for _, val := range varArgs {
+			if !val.IsKnown() && !spec.AllowUnknown {
+				return cty.UnknownVal(expectedType), nil
+			}
+		}
+	}
+
+	var retVal cty.Value
+	{
+		// Intercept any panics from the function and return them as normal errors,
+		// so a calling language runtime doesn't need to deal with panics.
+		defer func() {
+			if r := recover(); r != nil {
+				val = cty.NilVal
+				err = errorForPanic(r)
+			}
+		}()
+
+		retVal, err = f.spec.Impl(args, expectedType)
+		if err != nil {
+			return cty.NilVal, err
+		}
+	}
+
+	// Returned value must conform to what the Type function expected, to
+	// protect callers from having to deal with inconsistencies.
+	if errs := retVal.Type().TestConformance(expectedType); errs != nil {
+		panic(fmt.Errorf(
+			"returned value %#v does not conform to expected return type %#v: %s",
+			retVal, expectedType, errs[0],
+		))
+	}
+
+	return retVal, nil
+}
+
+// ProxyFunc the type returned by the method Function.Proxy.
+type ProxyFunc func(args ...cty.Value) (cty.Value, error)
+
+// Proxy returns a function that can be called with cty.Value arguments
+// to run the function. This is provided as a convenience for when using
+// a function directly within Go code.
+func (f Function) Proxy() ProxyFunc {
+	return func(args ...cty.Value) (cty.Value, error) {
+		return f.Call(args)
+	}
+}
+
+// Params returns information about the function's fixed positional parameters.
+// This does not include information about any variadic arguments accepted;
+// for that, call VarParam.
+func (f Function) Params() []Parameter {
+	new := make([]Parameter, len(f.spec.Params))
+	copy(new, f.spec.Params)
+	return new
+}
+
+// VarParam returns information about the variadic arguments the function
+// expects, or nil if the function is not variadic.
+func (f Function) VarParam() *Parameter {
+	if f.spec.VarParam == nil {
+		return nil
+	}
+
+	ret := *f.spec.VarParam
+	return &ret
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go
new file mode 100644
index 000000000..a473d0ec3
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bool.go
@@ -0,0 +1,73 @@
+package stdlib
+
+import (
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var NotFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "val",
+			Type:             cty.Bool,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		return args[0].Not(), nil
+	},
+})
+
+var AndFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Bool,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Bool,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		return args[0].And(args[1]), nil
+	},
+})
+
+var OrFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Bool,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Bool,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		return args[0].Or(args[1]), nil
+	},
+})
+
+// Not returns the logical complement of the given boolean value.
+func Not(num cty.Value) (cty.Value, error) {
+	return NotFunc.Call([]cty.Value{num})
+}
+
+// And returns true if and only if both of the given boolean values are true.
+func And(a, b cty.Value) (cty.Value, error) {
+	return AndFunc.Call([]cty.Value{a, b})
+}
+
+// Or returns true if either of the given boolean values are true.
+func Or(a, b cty.Value) (cty.Value, error) {
+	return OrFunc.Call([]cty.Value{a, b})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go
new file mode 100644
index 000000000..a132e0cde
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/bytes.go
@@ -0,0 +1,112 @@
+package stdlib
+
+import (
+	"fmt"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/gocty"
+)
+
+// Bytes is a capsule type that can be used with the binary functions to
+// support applications that need to support raw buffers in addition to
+// UTF-8 strings.
+var Bytes = cty.Capsule("bytes", reflect.TypeOf([]byte(nil)))
+
+// BytesVal creates a new Bytes value from the given buffer, which must be
+// non-nil or this function will panic.
+//
+// Once a byte slice has been wrapped in a Bytes capsule, its underlying array
+// must be considered immutable.
+func BytesVal(buf []byte) cty.Value {
+	if buf == nil {
+		panic("can't make Bytes value from nil slice")
+	}
+
+	return cty.CapsuleVal(Bytes, &buf)
+}
+
+// BytesLen is a Function that returns the length of the buffer encapsulated
+// in a Bytes value.
+var BytesLenFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "buf",
+			Type:             Bytes,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		bufPtr := args[0].EncapsulatedValue().(*[]byte)
+		return cty.NumberIntVal(int64(len(*bufPtr))), nil
+	},
+})
+
+// BytesSlice is a Function that returns a slice of the given Bytes value.
+var BytesSliceFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "buf",
+			Type:             Bytes,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "offset",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "length",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(Bytes),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		bufPtr := args[0].EncapsulatedValue().(*[]byte)
+
+		var offset, length int
+
+		var err error
+		err = gocty.FromCtyValue(args[1], &offset)
+		if err != nil {
+			return cty.NilVal, err
+		}
+		err = gocty.FromCtyValue(args[2], &length)
+		if err != nil {
+			return cty.NilVal, err
+		}
+
+		if offset < 0 || length < 0 {
+			return cty.NilVal, fmt.Errorf("offset and length must be non-negative")
+		}
+
+		if offset > len(*bufPtr) {
+			return cty.NilVal, fmt.Errorf(
+				"offset %d is greater than total buffer length %d",
+				offset, len(*bufPtr),
+			)
+		}
+
+		end := offset + length
+
+		if end > len(*bufPtr) {
+			return cty.NilVal, fmt.Errorf(
+				"offset %d + length %d is greater than total buffer length %d",
+				offset, length, len(*bufPtr),
+			)
+		}
+
+		return BytesVal((*bufPtr)[offset:end]), nil
+	},
+})
+
+func BytesLen(buf cty.Value) (cty.Value, error) {
+	return BytesLenFunc.Call([]cty.Value{buf})
+}
+
+func BytesSlice(buf cty.Value, offset cty.Value, length cty.Value) (cty.Value, error) {
+	return BytesSliceFunc.Call([]cty.Value{buf, offset, length})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go
new file mode 100644
index 000000000..967ba03c8
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/collection.go
@@ -0,0 +1,140 @@
+package stdlib
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/gocty"
+)
+
+var HasIndexFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "collection",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "key",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+	},
+	Type: func(args []cty.Value) (ret cty.Type, err error) {
+		collTy := args[0].Type()
+		if !(collTy.IsTupleType() || collTy.IsListType() || collTy.IsMapType() || collTy == cty.DynamicPseudoType) {
+			return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")
+		}
+		return cty.Bool, nil
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].HasIndex(args[1]), nil
+	},
+})
+
+var IndexFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "collection",
+			Type: cty.DynamicPseudoType,
+		},
+		{
+			Name:             "key",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+	},
+	Type: func(args []cty.Value) (ret cty.Type, err error) {
+		collTy := args[0].Type()
+		key := args[1]
+		keyTy := key.Type()
+		switch {
+		case collTy.IsTupleType():
+			if keyTy != cty.Number && keyTy != cty.DynamicPseudoType {
+				return cty.NilType, fmt.Errorf("key for tuple must be number")
+			}
+			if !key.IsKnown() {
+				return cty.DynamicPseudoType, nil
+			}
+			var idx int
+			err := gocty.FromCtyValue(key, &idx)
+			if err != nil {
+				return cty.NilType, fmt.Errorf("invalid key for tuple: %s", err)
+			}
+
+			etys := collTy.TupleElementTypes()
+
+			if idx >= len(etys) || idx < 0 {
+				return cty.NilType, fmt.Errorf("key must be between 0 and %d inclusive", len(etys))
+			}
+
+			return etys[idx], nil
+
+		case collTy.IsListType():
+			if keyTy != cty.Number && keyTy != cty.DynamicPseudoType {
+				return cty.NilType, fmt.Errorf("key for list must be number")
+			}
+
+			return collTy.ElementType(), nil
+
+		case collTy.IsMapType():
+			if keyTy != cty.String && keyTy != cty.DynamicPseudoType {
+				return cty.NilType, fmt.Errorf("key for map must be string")
+			}
+
+			return collTy.ElementType(), nil
+
+		default:
+			return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")
+		}
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		has, err := HasIndex(args[0], args[1])
+		if err != nil {
+			return cty.NilVal, err
+		}
+		if has.False() { // safe because collection and key are guaranteed known here
+			return cty.NilVal, fmt.Errorf("invalid index")
+		}
+
+		return args[0].Index(args[1]), nil
+	},
+})
+
+var LengthFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "collection",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+	},
+	Type: func(args []cty.Value) (ret cty.Type, err error) {
+		collTy := args[0].Type()
+		if !(collTy.IsTupleType() || collTy.IsListType() || collTy.IsMapType() || collTy.IsSetType() || collTy == cty.DynamicPseudoType) {
+			return cty.NilType, fmt.Errorf("collection must be a list, a map or a tuple")
+		}
+		return cty.Number, nil
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].Length(), nil
+	},
+})
+
+// HasIndex determines whether the given collection can be indexed with the
+// given key.
+func HasIndex(collection cty.Value, key cty.Value) (cty.Value, error) {
+	return HasIndexFunc.Call([]cty.Value{collection, key})
+}
+
+// Index returns an element from the given collection using the given key,
+// or returns an error if there is no element for the given key.
+func Index(collection cty.Value, key cty.Value) (cty.Value, error) {
+	return IndexFunc.Call([]cty.Value{collection, key})
+}
+
+// Length returns the number of elements in the given collection.
+func Length(collection cty.Value) (cty.Value, error) {
+	return LengthFunc.Call([]cty.Value{collection})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go
new file mode 100644
index 000000000..cfb613e5a
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/doc.go
@@ -0,0 +1,13 @@
+// Package stdlib is a collection of cty functions that are expected to be
+// generally useful, and are thus factored out into this shared library in
+// the hope that cty-using applications will have consistent behavior when
+// using these functions.
+//
+// See the parent package "function" for more information on the purpose
+// and usage of cty functions.
+//
+// This package contains both Go functions, which provide convenient access
+// to call the functions from Go code, and the Function objects themselves.
+// The latter follow the naming scheme of appending "Func" to the end of
+// the function name.
+package stdlib
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go
new file mode 100644
index 000000000..6b31f2661
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/general.go
@@ -0,0 +1,107 @@
+package stdlib
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var EqualFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.DynamicPseudoType,
+			AllowUnknown:     true,
+			AllowDynamicType: true,
+			AllowNull:        true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.DynamicPseudoType,
+			AllowUnknown:     true,
+			AllowDynamicType: true,
+			AllowNull:        true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].Equals(args[1]), nil
+	},
+})
+
+var NotEqualFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.DynamicPseudoType,
+			AllowUnknown:     true,
+			AllowDynamicType: true,
+			AllowNull:        true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.DynamicPseudoType,
+			AllowUnknown:     true,
+			AllowDynamicType: true,
+			AllowNull:        true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].Equals(args[1]).Not(), nil
+	},
+})
+
+var CoalesceFunc = function.New(&function.Spec{
+	Params: []function.Parameter{},
+	VarParam: &function.Parameter{
+		Name:             "vals",
+		Type:             cty.DynamicPseudoType,
+		AllowUnknown:     true,
+		AllowDynamicType: true,
+		AllowNull:        true,
+	},
+	Type: func(args []cty.Value) (ret cty.Type, err error) {
+		argTypes := make([]cty.Type, len(args))
+		for i, val := range args {
+			argTypes[i] = val.Type()
+		}
+		retType, _ := convert.UnifyUnsafe(argTypes)
+		if retType == cty.NilType {
+			return cty.NilType, fmt.Errorf("all arguments must have the same type")
+		}
+		return retType, nil
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		for _, argVal := range args {
+			if !argVal.IsKnown() {
+				return cty.UnknownVal(retType), nil
+			}
+			if argVal.IsNull() {
+				continue
+			}
+
+			return convert.Convert(argVal, retType)
+		}
+		return cty.NilVal, fmt.Errorf("no non-null arguments")
+	},
+})
+
+// Equal determines whether the two given values are equal, returning a
+// bool value.
+func Equal(a cty.Value, b cty.Value) (cty.Value, error) {
+	return EqualFunc.Call([]cty.Value{a, b})
+}
+
+// NotEqual is the opposite of Equal.
+func NotEqual(a cty.Value, b cty.Value) (cty.Value, error) {
+	return NotEqualFunc.Call([]cty.Value{a, b})
+}
+
+// Coalesce returns the first of the given arguments that is not null. If
+// all arguments are null, an error is produced.
+func Coalesce(vals ...cty.Value) (cty.Value, error) {
+	return CoalesceFunc.Call(vals)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go
new file mode 100644
index 000000000..6288a1e74
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/json.go
@@ -0,0 +1,65 @@
+package stdlib
+
+import (
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/json"
+)
+
+var JSONEncodeFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "val",
+			Type:             cty.DynamicPseudoType,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		val := args[0]
+		buf, err := json.Marshal(val, val.Type())
+		if err != nil {
+			return cty.NilVal, err
+		}
+
+		return cty.StringVal(string(buf)), nil
+	},
+})
+
+var JSONDecodeFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name: "str",
+			Type: cty.String,
+		},
+	},
+	Type: func(args []cty.Value) (cty.Type, error) {
+		str := args[0]
+		if !str.IsKnown() {
+			return cty.DynamicPseudoType, nil
+		}
+
+		buf := []byte(str.AsString())
+		return json.ImpliedType(buf)
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		buf := []byte(args[0].AsString())
+		return json.Unmarshal(buf, retType)
+	},
+})
+
+// JSONEncode returns a JSON serialization of the given value.
+func JSONEncode(val cty.Value) (cty.Value, error) {
+	return JSONEncodeFunc.Call([]cty.Value{val})
+}
+
+// JSONDecode parses the given JSON string and, if it is valid, returns the
+// value it represents.
+//
+// Note that applying JSONDecode to the result of JSONEncode may not produce
+// an identically-typed result, since JSON encoding is lossy for cty Types.
+// The resulting value will consist only of primitive types, object types, and
+// tuple types.
+func JSONDecode(str cty.Value) (cty.Value, error) {
+	return JSONDecodeFunc.Call([]cty.Value{str})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go
new file mode 100644
index 000000000..bd9b2e51b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/number.go
@@ -0,0 +1,428 @@
+package stdlib
+
+import (
+	"fmt"
+	"math/big"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var AbsoluteFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "num",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		return args[0].Absolute(), nil
+	},
+})
+
+var AddFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		// big.Float.Add can panic if the input values are opposing infinities,
+		// so we must catch that here in order to remain within
+		// the cty Function abstraction.
+		defer func() {
+			if r := recover(); r != nil {
+				if _, ok := r.(big.ErrNaN); ok {
+					ret = cty.NilVal
+					err = fmt.Errorf("can't compute sum of opposing infinities")
+				} else {
+					// not a panic we recognize
+					panic(r)
+				}
+			}
+		}()
+		return args[0].Add(args[1]), nil
+	},
+})
+
+var SubtractFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		// big.Float.Sub can panic if the input values are infinities,
+		// so we must catch that here in order to remain within
+		// the cty Function abstraction.
+		defer func() {
+			if r := recover(); r != nil {
+				if _, ok := r.(big.ErrNaN); ok {
+					ret = cty.NilVal
+					err = fmt.Errorf("can't subtract infinity from itself")
+				} else {
+					// not a panic we recognize
+					panic(r)
+				}
+			}
+		}()
+		return args[0].Subtract(args[1]), nil
+	},
+})
+
+var MultiplyFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		// big.Float.Mul can panic if the input values are both zero or both
+		// infinity, so we must catch that here in order to remain within
+		// the cty Function abstraction.
+		defer func() {
+			if r := recover(); r != nil {
+				if _, ok := r.(big.ErrNaN); ok {
+					ret = cty.NilVal
+					err = fmt.Errorf("can't multiply zero by infinity")
+				} else {
+					// not a panic we recognize
+					panic(r)
+				}
+			}
+		}()
+
+		return args[0].Multiply(args[1]), nil
+	},
+})
+
+var DivideFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		// big.Float.Quo can panic if the input values are both zero or both
+		// infinity, so we must catch that here in order to remain within
+		// the cty Function abstraction.
+		defer func() {
+			if r := recover(); r != nil {
+				if _, ok := r.(big.ErrNaN); ok {
+					ret = cty.NilVal
+					err = fmt.Errorf("can't divide zero by zero or infinity by infinity")
+				} else {
+					// not a panic we recognize
+					panic(r)
+				}
+			}
+		}()
+
+		return args[0].Divide(args[1]), nil
+	},
+})
+
+var ModuloFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		// big.Float.Mul can panic if the input values are both zero or both
+		// infinity, so we must catch that here in order to remain within
+		// the cty Function abstraction.
+		defer func() {
+			if r := recover(); r != nil {
+				if _, ok := r.(big.ErrNaN); ok {
+					ret = cty.NilVal
+					err = fmt.Errorf("can't use modulo with zero and infinity")
+				} else {
+					// not a panic we recognize
+					panic(r)
+				}
+			}
+		}()
+
+		return args[0].Modulo(args[1]), nil
+	},
+})
+
+var GreaterThanFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].GreaterThan(args[1]), nil
+	},
+})
+
+var GreaterThanOrEqualToFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].GreaterThanOrEqualTo(args[1]), nil
+	},
+})
+
+var LessThanFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].LessThan(args[1]), nil
+	},
+})
+
+var LessThanOrEqualToFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "a",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "b",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Bool),
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		return args[0].LessThanOrEqualTo(args[1]), nil
+	},
+})
+
+var NegateFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "num",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		return args[0].Negate(), nil
+	},
+})
+
+var MinFunc = function.New(&function.Spec{
+	Params: []function.Parameter{},
+	VarParam: &function.Parameter{
+		Name:             "numbers",
+		Type:             cty.Number,
+		AllowDynamicType: true,
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		if len(args) == 0 {
+			return cty.NilVal, fmt.Errorf("must pass at least one number")
+		}
+
+		min := cty.PositiveInfinity
+		for _, num := range args {
+			if num.LessThan(min).True() {
+				min = num
+			}
+		}
+
+		return min, nil
+	},
+})
+
+var MaxFunc = function.New(&function.Spec{
+	Params: []function.Parameter{},
+	VarParam: &function.Parameter{
+		Name:             "numbers",
+		Type:             cty.Number,
+		AllowDynamicType: true,
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		if len(args) == 0 {
+			return cty.NilVal, fmt.Errorf("must pass at least one number")
+		}
+
+		max := cty.NegativeInfinity
+		for _, num := range args {
+			if num.GreaterThan(max).True() {
+				max = num
+			}
+		}
+
+		return max, nil
+	},
+})
+
+var IntFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "num",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		bf := args[0].AsBigFloat()
+		if bf.IsInt() {
+			return args[0], nil
+		}
+		bi, _ := bf.Int(nil)
+		bf = (&big.Float{}).SetInt(bi)
+		return cty.NumberVal(bf), nil
+	},
+})
+
+// Absolute returns the magnitude of the given number, without its sign.
+// That is, it turns negative values into positive values.
+func Absolute(num cty.Value) (cty.Value, error) {
+	return AbsoluteFunc.Call([]cty.Value{num})
+}
+
+// Add returns the sum of the two given numbers.
+func Add(a cty.Value, b cty.Value) (cty.Value, error) {
+	return AddFunc.Call([]cty.Value{a, b})
+}
+
+// Subtract returns the difference between the two given numbers.
+func Subtract(a cty.Value, b cty.Value) (cty.Value, error) {
+	return SubtractFunc.Call([]cty.Value{a, b})
+}
+
+// Multiply returns the product of the two given numbers.
+func Multiply(a cty.Value, b cty.Value) (cty.Value, error) {
+	return MultiplyFunc.Call([]cty.Value{a, b})
+}
+
+// Divide returns a divided by b, where both a and b are numbers.
+func Divide(a cty.Value, b cty.Value) (cty.Value, error) {
+	return DivideFunc.Call([]cty.Value{a, b})
+}
+
+// Negate returns the given number multipled by -1.
+func Negate(num cty.Value) (cty.Value, error) {
+	return NegateFunc.Call([]cty.Value{num})
+}
+
+// LessThan returns true if a is less than b.
+func LessThan(a cty.Value, b cty.Value) (cty.Value, error) {
+	return LessThanFunc.Call([]cty.Value{a, b})
+}
+
+// LessThanOrEqualTo returns true if a is less than b.
+func LessThanOrEqualTo(a cty.Value, b cty.Value) (cty.Value, error) {
+	return LessThanOrEqualToFunc.Call([]cty.Value{a, b})
+}
+
+// GreaterThan returns true if a is less than b.
+func GreaterThan(a cty.Value, b cty.Value) (cty.Value, error) {
+	return GreaterThanFunc.Call([]cty.Value{a, b})
+}
+
+// GreaterThanOrEqualTo returns true if a is less than b.
+func GreaterThanOrEqualTo(a cty.Value, b cty.Value) (cty.Value, error) {
+	return GreaterThanOrEqualToFunc.Call([]cty.Value{a, b})
+}
+
+// Modulo returns the remainder of a divided by b under integer division,
+// where both a and b are numbers.
+func Modulo(a cty.Value, b cty.Value) (cty.Value, error) {
+	return ModuloFunc.Call([]cty.Value{a, b})
+}
+
+// Min returns the minimum number from the given numbers.
+func Min(numbers ...cty.Value) (cty.Value, error) {
+	return MinFunc.Call(numbers)
+}
+
+// Max returns the maximum number from the given numbers.
+func Max(numbers ...cty.Value) (cty.Value, error) {
+	return MaxFunc.Call(numbers)
+}
+
+// Int removes the fractional component of the given number returning an
+// integer representing the whole number component, rounding towards zero.
+// For example, -1.5 becomes -1.
+//
+// If an infinity is passed to Int, an error is returned.
+func Int(num cty.Value) (cty.Value, error) {
+	if num == cty.PositiveInfinity || num == cty.NegativeInfinity {
+		return cty.NilVal, fmt.Errorf("can't truncate infinity to an integer")
+	}
+	return IntFunc.Call([]cty.Value{num})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
new file mode 100644
index 000000000..e2c77c5d3
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/sequence.go
@@ -0,0 +1,130 @@
+package stdlib
+
+import (
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+	"github.com/zclconf/go-cty/cty/function"
+)
+
+var ConcatFunc = function.New(&function.Spec{
+	Params: []function.Parameter{},
+	VarParam: &function.Parameter{
+		Name: "seqs",
+		Type: cty.DynamicPseudoType,
+	},
+	Type: func(args []cty.Value) (ret cty.Type, err error) {
+		if len(args) == 0 {
+			return cty.NilType, fmt.Errorf("at least one argument is required")
+		}
+
+		if args[0].Type().IsListType() {
+			// Possibly we're going to return a list, if all of our other
+			// args are also lists and we can find a common element type.
+			tys := make([]cty.Type, len(args))
+			for i, val := range args {
+				ty := val.Type()
+				if !ty.IsListType() {
+					tys = nil
+					break
+				}
+				tys[i] = ty
+			}
+
+			if tys != nil {
+				commonType, _ := convert.UnifyUnsafe(tys)
+				if commonType != cty.NilType {
+					return commonType, nil
+				}
+			}
+		}
+
+		etys := make([]cty.Type, 0, len(args))
+		for i, val := range args {
+			ety := val.Type()
+			switch {
+			case ety.IsTupleType():
+				etys = append(etys, ety.TupleElementTypes()...)
+			case ety.IsListType():
+				if !val.IsKnown() {
+					// We need to know the list to count its elements to
+					// build our tuple type, so any concat of an unknown
+					// list can't be typed yet.
+					return cty.DynamicPseudoType, nil
+				}
+
+				l := val.LengthInt()
+				subEty := ety.ElementType()
+				for j := 0; j < l; j++ {
+					etys = append(etys, subEty)
+				}
+			default:
+				return cty.NilType, function.NewArgErrorf(
+					i, "all arguments must be lists or tuples; got %s",
+					ety.FriendlyName(),
+				)
+			}
+		}
+		return cty.Tuple(etys), nil
+	},
+	Impl: func(args []cty.Value, retType cty.Type) (ret cty.Value, err error) {
+		switch {
+		case retType.IsListType():
+			// If retType is a list type then we know that all of the
+			// given values will be lists and that they will either be of
+			// retType or of something we can convert to retType.
+			vals := make([]cty.Value, 0, len(args))
+			for i, list := range args {
+				list, err = convert.Convert(list, retType)
+				if err != nil {
+					// Conversion might fail because we used UnifyUnsafe
+					// to choose our return type.
+					return cty.NilVal, function.NewArgError(i, err)
+				}
+
+				it := list.ElementIterator()
+				for it.Next() {
+					_, v := it.Element()
+					vals = append(vals, v)
+				}
+			}
+			if len(vals) == 0 {
+				return cty.ListValEmpty(retType.ElementType()), nil
+			}
+
+			return cty.ListVal(vals), nil
+		case retType.IsTupleType():
+			// If retType is a tuple type then we could have a mixture of
+			// lists and tuples but we know they all have known values
+			// (because our params don't AllowUnknown) and we know that
+			// concatenating them all together will produce a tuple of
+			// retType because of the work we did in the Type function above.
+			vals := make([]cty.Value, 0, len(args))
+
+			for _, seq := range args {
+				// Both lists and tuples support ElementIterator, so this is easy.
+				it := seq.ElementIterator()
+				for it.Next() {
+					_, v := it.Element()
+					vals = append(vals, v)
+				}
+			}
+
+			return cty.TupleVal(vals), nil
+		default:
+			// should never happen if Type is working correctly above
+			panic("unsupported return type")
+		}
+	},
+})
+
+// Concat takes one or more sequences (lists or tuples) and returns the single
+// sequence that results from concatenating them together in order.
+//
+// If all of the given sequences are lists of the same element type then the
+// result is a list of that type. Otherwise, the result is a of a tuple type
+// constructed from the given sequence types.
+func Concat(seqs ...cty.Value) (cty.Value, error) {
+	return ConcatFunc.Call(seqs)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go
new file mode 100644
index 000000000..d7c89fa82
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/function/stdlib/string.go
@@ -0,0 +1,234 @@
+package stdlib
+
+import (
+	"strings"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/function"
+	"github.com/zclconf/go-cty/cty/gocty"
+	"github.com/apparentlymart/go-textseg/textseg"
+)
+
+var UpperFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "str",
+			Type:             cty.String,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		in := args[0].AsString()
+		out := strings.ToUpper(in)
+		return cty.StringVal(out), nil
+	},
+})
+
+var LowerFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "str",
+			Type:             cty.String,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		in := args[0].AsString()
+		out := strings.ToLower(in)
+		return cty.StringVal(out), nil
+	},
+})
+
+var ReverseFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "str",
+			Type:             cty.String,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		in := []byte(args[0].AsString())
+		out := make([]byte, len(in))
+		pos := len(out)
+
+		inB := []byte(in)
+		for i := 0; i < len(in); {
+			d, _, _ := textseg.ScanGraphemeClusters(inB[i:], true)
+			cluster := in[i : i+d]
+			pos -= len(cluster)
+			copy(out[pos:], cluster)
+			i += d
+		}
+
+		return cty.StringVal(string(out)), nil
+	},
+})
+
+var StrlenFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "str",
+			Type:             cty.String,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.Number),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		in := args[0].AsString()
+		l := 0
+
+		inB := []byte(in)
+		for i := 0; i < len(in); {
+			d, _, _ := textseg.ScanGraphemeClusters(inB[i:], true)
+			l++
+			i += d
+		}
+
+		return cty.NumberIntVal(int64(l)), nil
+	},
+})
+
+var SubstrFunc = function.New(&function.Spec{
+	Params: []function.Parameter{
+		{
+			Name:             "str",
+			Type:             cty.String,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "offset",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+		{
+			Name:             "length",
+			Type:             cty.Number,
+			AllowDynamicType: true,
+		},
+	},
+	Type: function.StaticReturnType(cty.String),
+	Impl: func(args []cty.Value, retType cty.Type) (cty.Value, error) {
+		in := []byte(args[0].AsString())
+		var offset, length int
+
+		var err error
+		err = gocty.FromCtyValue(args[1], &offset)
+		if err != nil {
+			return cty.NilVal, err
+		}
+		err = gocty.FromCtyValue(args[2], &length)
+		if err != nil {
+			return cty.NilVal, err
+		}
+
+		if offset < 0 {
+			totalLenNum, err := Strlen(args[0])
+			if err != nil {
+				// should never happen
+				panic("Stdlen returned an error")
+			}
+
+			var totalLen int
+			err = gocty.FromCtyValue(totalLenNum, &totalLen)
+			if err != nil {
+				// should never happen
+				panic("Stdlen returned a non-int number")
+			}
+
+			offset += totalLen
+		}
+
+		sub := in
+		pos := 0
+		var i int
+
+		// First we'll seek forward to our offset
+		if offset > 0 {
+			for i = 0; i < len(sub); {
+				d, _, _ := textseg.ScanGraphemeClusters(sub[i:], true)
+				i += d
+				pos++
+				if pos == offset {
+					break
+				}
+				if i >= len(in) {
+					return cty.StringVal(""), nil
+				}
+			}
+
+			sub = sub[i:]
+		}
+
+		if length < 0 {
+			// Taking the remainder of the string is a fast path since
+			// we can just return the rest of the buffer verbatim.
+			return cty.StringVal(string(sub)), nil
+		}
+
+		// Otherwise we need to start seeking forward again until we
+		// reach the length we want.
+		pos = 0
+		for i = 0; i < len(sub); {
+			d, _, _ := textseg.ScanGraphemeClusters(sub[i:], true)
+			i += d
+			pos++
+			if pos == length {
+				break
+			}
+		}
+
+		sub = sub[:i]
+
+		return cty.StringVal(string(sub)), nil
+	},
+})
+
+// Upper is a Function that converts a given string to uppercase.
+func Upper(str cty.Value) (cty.Value, error) {
+	return UpperFunc.Call([]cty.Value{str})
+}
+
+// Lower is a Function that converts a given string to lowercase.
+func Lower(str cty.Value) (cty.Value, error) {
+	return LowerFunc.Call([]cty.Value{str})
+}
+
+// Reverse is a Function that reverses the order of the characters in the
+// given string.
+//
+// As usual, "character" for the sake of this function is a grapheme cluster,
+// so combining diacritics (for example) will be considered together as a
+// single character.
+func Reverse(str cty.Value) (cty.Value, error) {
+	return ReverseFunc.Call([]cty.Value{str})
+}
+
+// Strlen is a Function that returns the length of the given string in
+// characters.
+//
+// As usual, "character" for the sake of this function is a grapheme cluster,
+// so combining diacritics (for example) will be considered together as a
+// single character.
+func Strlen(str cty.Value) (cty.Value, error) {
+	return StrlenFunc.Call([]cty.Value{str})
+}
+
+// Substr is a Function that extracts a sequence of characters from another
+// string and creates a new string.
+//
+// As usual, "character" for the sake of this function is a grapheme cluster,
+// so combining diacritics (for example) will be considered together as a
+// single character.
+//
+// The "offset" index may be negative, in which case it is relative to the
+// end of the given string.
+//
+// The "length" may be -1, in which case the remainder of the string after
+// the given offset will be returned.
+func Substr(str cty.Value, offset cty.Value, length cty.Value) (cty.Value, error) {
+	return SubstrFunc.Call([]cty.Value{str, offset, length})
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gob.go b/vendor/github.com/zclconf/go-cty/cty/gob.go
new file mode 100644
index 000000000..3d731993b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gob.go
@@ -0,0 +1,125 @@
+package cty
+
+import (
+	"bytes"
+	"encoding/gob"
+	"fmt"
+	"math/big"
+)
+
+// GobEncode is an implementation of the gob.GobEncoder interface, which
+// allows Values to be included in structures encoded with encoding/gob.
+//
+// Currently it is not possible to represent values of capsule types in gob,
+// because the types themselves cannot be represented.
+func (val Value) GobEncode() ([]byte, error) {
+	buf := &bytes.Buffer{}
+	enc := gob.NewEncoder(buf)
+
+	gv := gobValue{
+		Version: 0,
+		Ty:      val.ty,
+		V:       val.v,
+	}
+
+	err := enc.Encode(gv)
+	if err != nil {
+		return nil, fmt.Errorf("error encoding cty.Value: %s", err)
+	}
+
+	return buf.Bytes(), nil
+}
+
+// GobDecode is an implementation of the gob.GobDecoder interface, which
+// inverts the operation performed by GobEncode. See the documentation of
+// GobEncode for considerations when using cty.Value instances with gob.
+func (val *Value) GobDecode(buf []byte) error {
+	r := bytes.NewReader(buf)
+	dec := gob.NewDecoder(r)
+
+	var gv gobValue
+	err := dec.Decode(&gv)
+	if err != nil {
+		return fmt.Errorf("error decoding cty.Value: %s", err)
+	}
+	if gv.Version != 0 {
+		return fmt.Errorf("unsupported cty.Value encoding version %d; only 0 is supported", gv.Version)
+	}
+
+	// big.Float seems to, for some reason, lose its "pointerness" when we
+	// round-trip it, so we'll fix that here.
+	if bf, ok := gv.V.(big.Float); ok {
+		gv.V = &bf
+	}
+
+	val.ty = gv.Ty
+	val.v = gv.V
+
+	return nil
+}
+
+// GobEncode is an implementation of the gob.GobEncoder interface, which
+// allows Types to be included in structures encoded with encoding/gob.
+//
+// Currently it is not possible to represent capsule types in gob.
+func (t Type) GobEncode() ([]byte, error) {
+	buf := &bytes.Buffer{}
+	enc := gob.NewEncoder(buf)
+
+	gt := gobType{
+		Version: 0,
+		Impl:    t.typeImpl,
+	}
+
+	err := enc.Encode(gt)
+	if err != nil {
+		return nil, fmt.Errorf("error encoding cty.Type: %s", err)
+	}
+
+	return buf.Bytes(), nil
+}
+
+// GobDecode is an implementatino of the gob.GobDecoder interface, which
+// reverses the encoding performed by GobEncode to allow types to be recovered
+// from gob buffers.
+func (t *Type) GobDecode(buf []byte) error {
+	r := bytes.NewReader(buf)
+	dec := gob.NewDecoder(r)
+
+	var gt gobType
+	err := dec.Decode(&gt)
+	if err != nil {
+		return fmt.Errorf("error decoding cty.Type: %s", err)
+	}
+	if gt.Version != 0 {
+		return fmt.Errorf("unsupported cty.Type encoding version %d; only 0 is supported", gt.Version)
+	}
+
+	t.typeImpl = gt.Impl
+
+	return nil
+}
+
+// Capsule types cannot currently be gob-encoded, because they rely on pointer
+// equality and we have no way to recover the original pointer on decode.
+func (t *capsuleType) GobEncode() ([]byte, error) {
+	return nil, fmt.Errorf("cannot gob-encode capsule type %q", t.FriendlyName())
+}
+
+func (t *capsuleType) GobDecode() ([]byte, error) {
+	return nil, fmt.Errorf("cannot gob-decode capsule type %q", t.FriendlyName())
+}
+
+type gobValue struct {
+	Version int
+	Ty      Type
+	V       interface{}
+}
+
+type gobType struct {
+	Version int
+	Impl    typeImpl
+}
+
+type gobCapsuleTypeImpl struct {
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/doc.go b/vendor/github.com/zclconf/go-cty/cty/gocty/doc.go
new file mode 100644
index 000000000..a5177d22b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/doc.go
@@ -0,0 +1,7 @@
+// Package gocty deals with converting between cty Values and native go
+// values.
+//
+// It operates under a similar principle to the encoding/json and
+// encoding/xml packages in the standard library, using reflection to
+// populate native Go data structures from cty values and vice-versa.
+package gocty
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/helpers.go b/vendor/github.com/zclconf/go-cty/cty/gocty/helpers.go
new file mode 100644
index 000000000..94ffd2fb7
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/helpers.go
@@ -0,0 +1,43 @@
+package gocty
+
+import (
+	"math/big"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+var valueType = reflect.TypeOf(cty.Value{})
+var typeType = reflect.TypeOf(cty.Type{})
+
+var setType = reflect.TypeOf(set.Set{})
+
+var bigFloatType = reflect.TypeOf(big.Float{})
+var bigIntType = reflect.TypeOf(big.Int{})
+
+var emptyInterfaceType = reflect.TypeOf(interface{}(nil))
+
+var stringType = reflect.TypeOf("")
+
+// structTagIndices interrogates the fields of the given type (which must
+// be a struct type, or we'll panic) and returns a map from the cty
+// attribute names declared via struct tags to the indices of the
+// fields holding those tags.
+//
+// This function will panic if two fields within the struct are tagged with
+// the same cty attribute name.
+func structTagIndices(st reflect.Type) map[string]int {
+	ct := st.NumField()
+	ret := make(map[string]int, ct)
+
+	for i := 0; i < ct; i++ {
+		field := st.Field(i)
+		attrName := field.Tag.Get("cty")
+		if attrName != "" {
+			ret[attrName] = i
+		}
+	}
+
+	return ret
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/in.go b/vendor/github.com/zclconf/go-cty/cty/gocty/in.go
new file mode 100644
index 000000000..642501b25
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/in.go
@@ -0,0 +1,528 @@
+package gocty
+
+import (
+	"math/big"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+// ToCtyValue produces a cty.Value from a Go value. The result will conform
+// to the given type, or an error will be returned if this is not possible.
+//
+// The target type serves as a hint to resolve ambiguities in the mapping.
+// For example, the Go type set.Set tells us that the value is a set but
+// does not describe the set's element type. This also allows for convenient
+// conversions, such as populating a set from a slice rather than having to
+// first explicitly instantiate a set.Set.
+//
+// The audience of this function is assumed to be the developers of Go code
+// that is integrating with cty, and thus the error messages it returns are
+// presented from Go's perspective. These messages are thus not appropriate
+// for display to end-users. An error returned from ToCtyValue represents a
+// bug in the calling program, not user error.
+func ToCtyValue(val interface{}, ty cty.Type) (cty.Value, error) {
+	// 'path' starts off as empty but will grow for each level of recursive
+	// call we make, so by the time toCtyValue returns it is likely to have
+	// unused capacity on the end of it, depending on how deeply-recursive
+	// the given Type is.
+	path := make(cty.Path, 0)
+	return toCtyValue(reflect.ValueOf(val), ty, path)
+}
+
+func toCtyValue(val reflect.Value, ty cty.Type, path cty.Path) (cty.Value, error) {
+
+	switch ty {
+	case cty.Bool:
+		return toCtyBool(val, path)
+	case cty.Number:
+		return toCtyNumber(val, path)
+	case cty.String:
+		return toCtyString(val, path)
+	case cty.DynamicPseudoType:
+		return toCtyDynamic(val, path)
+	}
+
+	switch {
+	case ty.IsListType():
+		return toCtyList(val, ty.ElementType(), path)
+	case ty.IsMapType():
+		return toCtyMap(val, ty.ElementType(), path)
+	case ty.IsSetType():
+		return toCtySet(val, ty.ElementType(), path)
+	case ty.IsObjectType():
+		return toCtyObject(val, ty.AttributeTypes(), path)
+	case ty.IsTupleType():
+		return toCtyTuple(val, ty.TupleElementTypes(), path)
+	case ty.IsCapsuleType():
+		return toCtyCapsule(val, ty, path)
+	}
+
+	// We should never fall out here
+	return cty.NilVal, path.NewErrorf("unsupported target type %#v", ty)
+}
+
+func toCtyBool(val reflect.Value, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Bool), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Bool:
+		return cty.BoolVal(val.Bool()), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to bool", val.Kind())
+
+	}
+
+}
+
+func toCtyNumber(val reflect.Value, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Number), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return cty.NumberIntVal(val.Int()), nil
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return cty.NumberUIntVal(val.Uint()), nil
+
+	case reflect.Float32, reflect.Float64:
+		return cty.NumberFloatVal(val.Float()), nil
+
+	case reflect.Struct:
+		if val.Type().AssignableTo(bigIntType) {
+			bigInt := val.Interface().(big.Int)
+			bigFloat := (&big.Float{}).SetInt(&bigInt)
+			val = reflect.ValueOf(*bigFloat)
+		}
+
+		if val.Type().AssignableTo(bigFloatType) {
+			bigFloat := val.Interface().(big.Float)
+			return cty.NumberVal(&bigFloat), nil
+		}
+
+		fallthrough
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to number", val.Kind())
+
+	}
+
+}
+
+func toCtyString(val reflect.Value, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.String), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.String:
+		return cty.StringVal(val.String()), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to string", val.Kind())
+
+	}
+
+}
+
+func toCtyList(val reflect.Value, ety cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.List(ety)), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Slice:
+		if val.IsNil() {
+			return cty.NullVal(cty.List(ety)), nil
+		}
+		fallthrough
+	case reflect.Array:
+		if val.Len() == 0 {
+			return cty.ListValEmpty(ety), nil
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our index step.
+		path = append(path, cty.PathStep(nil))
+
+		vals := make([]cty.Value, val.Len())
+		for i := range vals {
+			var err error
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+			vals[i], err = toCtyValue(val.Index(i), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.ListVal(vals), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.List(ety))
+
+	}
+}
+
+func toCtyMap(val reflect.Value, ety cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Map(ety)), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Map:
+		if val.IsNil() {
+			return cty.NullVal(cty.Map(ety)), nil
+		}
+
+		if val.Len() == 0 {
+			return cty.MapValEmpty(ety), nil
+		}
+
+		keyType := val.Type().Key()
+		if keyType.Kind() != reflect.String {
+			return cty.NilVal, path.NewErrorf("can't convert Go map with key type %s; key type must be string", keyType)
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our index step.
+		path = append(path, cty.PathStep(nil))
+
+		vals := make(map[string]cty.Value, val.Len())
+		for _, kv := range val.MapKeys() {
+			k := kv.String()
+			var err error
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.StringVal(k),
+			}
+			vals[k], err = toCtyValue(val.MapIndex(reflect.ValueOf(k)), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.MapVal(vals), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Map(ety))
+
+	}
+}
+
+func toCtySet(val reflect.Value, ety cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Set(ety)), nil
+	}
+
+	var vals []cty.Value
+
+	switch val.Kind() {
+
+	case reflect.Slice:
+		if val.IsNil() {
+			return cty.NullVal(cty.Set(ety)), nil
+		}
+		fallthrough
+	case reflect.Array:
+		if val.Len() == 0 {
+			return cty.SetValEmpty(ety), nil
+		}
+
+		vals = make([]cty.Value, val.Len())
+		for i := range vals {
+			var err error
+			vals[i], err = toCtyValue(val.Index(i), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+	case reflect.Struct:
+
+		if !val.Type().AssignableTo(setType) {
+			return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Type(), cty.Set(ety))
+		}
+
+		rawSet := val.Interface().(set.Set)
+		inVals := rawSet.Values()
+
+		if len(inVals) == 0 {
+			return cty.SetValEmpty(ety), nil
+		}
+
+		vals = make([]cty.Value, len(inVals))
+		for i := range inVals {
+			var err error
+			vals[i], err = toCtyValue(reflect.ValueOf(inVals[i]), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Set(ety))
+
+	}
+
+	return cty.SetVal(vals), nil
+}
+
+func toCtyObject(val reflect.Value, attrTypes map[string]cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Object(attrTypes)), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Map:
+		if val.IsNil() {
+			return cty.NullVal(cty.Object(attrTypes)), nil
+		}
+
+		keyType := val.Type().Key()
+		if keyType.Kind() != reflect.String {
+			return cty.NilVal, path.NewErrorf("can't convert Go map with key type %s; key type must be string", keyType)
+		}
+
+		if len(attrTypes) == 0 {
+			return cty.EmptyObjectVal, nil
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our GetAttr step.
+		path = append(path, cty.PathStep(nil))
+
+		haveKeys := make(map[string]struct{}, val.Len())
+		for _, kv := range val.MapKeys() {
+			haveKeys[kv.String()] = struct{}{}
+		}
+
+		vals := make(map[string]cty.Value, len(attrTypes))
+		for k, at := range attrTypes {
+			var err error
+			path[len(path)-1] = cty.GetAttrStep{
+				Name: k,
+			}
+
+			if _, have := haveKeys[k]; !have {
+				vals[k] = cty.NullVal(at)
+				continue
+			}
+
+			vals[k], err = toCtyValue(val.MapIndex(reflect.ValueOf(k)), at, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.ObjectVal(vals), nil
+
+	case reflect.Struct:
+		if len(attrTypes) == 0 {
+			return cty.EmptyObjectVal, nil
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our GetAttr step.
+		path = append(path, cty.PathStep(nil))
+
+		attrFields := structTagIndices(val.Type())
+
+		vals := make(map[string]cty.Value, len(attrTypes))
+		for k, at := range attrTypes {
+			path[len(path)-1] = cty.GetAttrStep{
+				Name: k,
+			}
+
+			if fieldIdx, have := attrFields[k]; have {
+				var err error
+				vals[k], err = toCtyValue(val.Field(fieldIdx), at, path)
+				if err != nil {
+					return cty.NilVal, err
+				}
+			} else {
+				vals[k] = cty.NullVal(at)
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.ObjectVal(vals), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Object(attrTypes))
+
+	}
+}
+
+func toCtyTuple(val reflect.Value, elemTypes []cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.Tuple(elemTypes)), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Slice:
+		if val.IsNil() {
+			return cty.NullVal(cty.Tuple(elemTypes)), nil
+		}
+
+		if val.Len() != len(elemTypes) {
+			return cty.NilVal, path.NewErrorf("wrong number of elements %d; need %d", val.Len(), len(elemTypes))
+		}
+
+		if len(elemTypes) == 0 {
+			return cty.EmptyTupleVal, nil
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our Index step.
+		path = append(path, cty.PathStep(nil))
+
+		vals := make([]cty.Value, len(elemTypes))
+		for i, ety := range elemTypes {
+			var err error
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			vals[i], err = toCtyValue(val.Index(i), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.TupleVal(vals), nil
+
+	case reflect.Struct:
+		fieldCount := val.Type().NumField()
+		if fieldCount != len(elemTypes) {
+			return cty.NilVal, path.NewErrorf("wrong number of struct fields %d; need %d", fieldCount, len(elemTypes))
+		}
+
+		if len(elemTypes) == 0 {
+			return cty.EmptyTupleVal, nil
+		}
+
+		// While we work on our elements we'll temporarily grow
+		// path to give us a place to put our Index step.
+		path = append(path, cty.PathStep(nil))
+
+		vals := make([]cty.Value, len(elemTypes))
+		for i, ety := range elemTypes {
+			var err error
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			vals[i], err = toCtyValue(val.Field(i), ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+		}
+
+		// Discard our extra path segment, retaining it as extra capacity
+		// for future appending to the path.
+		path = path[:len(path)-1]
+
+		return cty.TupleVal(vals), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s to %#v", val.Kind(), cty.Tuple(elemTypes))
+
+	}
+}
+
+func toCtyCapsule(val reflect.Value, capsuleType cty.Type, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(capsuleType), nil
+	}
+
+	if val.Kind() != reflect.Ptr {
+		if !val.CanAddr() {
+			return cty.NilVal, path.NewErrorf("source value for capsule %#v must be addressable", capsuleType)
+		}
+
+		val = val.Addr()
+	}
+
+	if !val.Type().Elem().AssignableTo(capsuleType.EncapsulatedType()) {
+		return cty.NilVal, path.NewErrorf("value of type %T not compatible with capsule %#v", val.Interface(), capsuleType)
+	}
+
+	return cty.CapsuleVal(capsuleType, val.Interface()), nil
+}
+
+func toCtyDynamic(val reflect.Value, path cty.Path) (cty.Value, error) {
+	if val = toCtyUnwrapPointer(val); !val.IsValid() {
+		return cty.NullVal(cty.DynamicPseudoType), nil
+	}
+
+	switch val.Kind() {
+
+	case reflect.Struct:
+		if !val.Type().AssignableTo(valueType) {
+			return cty.NilVal, path.NewErrorf("can't convert Go %s dynamically; only cty.Value allowed", val.Type())
+		}
+
+		return val.Interface().(cty.Value), nil
+
+	default:
+		return cty.NilVal, path.NewErrorf("can't convert Go %s dynamically; only cty.Value allowed", val.Kind())
+
+	}
+
+}
+
+// toCtyUnwrapPointer is a helper for dealing with Go pointers. It has three
+// possible outcomes:
+//
+// - Given value isn't a pointer, so it's just returned as-is.
+// - Given value is a non-nil pointer, in which case it is dereferenced
+//   and the result returned.
+// - Given value is a nil pointer, in which case an invalid value is returned.
+//
+// For nested pointer types, like **int, they are all dereferenced in turn
+// until a non-pointer value is found, or until a nil pointer is encountered.
+func toCtyUnwrapPointer(val reflect.Value) reflect.Value {
+	for val.Kind() == reflect.Ptr || val.Kind() == reflect.Interface {
+		if val.IsNil() {
+			return reflect.Value{}
+		}
+
+		val = val.Elem()
+	}
+
+	return val
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/out.go b/vendor/github.com/zclconf/go-cty/cty/gocty/out.go
new file mode 100644
index 000000000..99b65a767
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/out.go
@@ -0,0 +1,705 @@
+package gocty
+
+import (
+	"math/big"
+	"reflect"
+
+	"math"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+// FromCtyValue assigns a cty.Value to a reflect.Value, which must be a pointer,
+// using a fixed set of conversion rules.
+//
+// This function considers its audience to be the creator of the cty Value
+// given, and thus the error messages it generates are (unlike with ToCtyValue)
+// presented in cty terminology that is generally appropriate to return to
+// end-users in applications where cty data structures are built from
+// user-provided configuration. In particular this means that if incorrect
+// target types are provided by the calling application the resulting error
+// messages are likely to be confusing, since we assume that the given target
+// type is correct and the cty.Value is where the error lies.
+//
+// If an error is returned, the target data structure may have been partially
+// populated, but the degree to which this is true is an implementation
+// detail that the calling application should not rely on.
+//
+// The function will panic if given a non-pointer as the Go value target,
+// since that is considered to be a bug in the calling program.
+func FromCtyValue(val cty.Value, target interface{}) error {
+	tVal := reflect.ValueOf(target)
+	if tVal.Kind() != reflect.Ptr {
+		panic("target value is not a pointer")
+	}
+	if tVal.IsNil() {
+		panic("target value is nil pointer")
+	}
+
+	// 'path' starts off as empty but will grow for each level of recursive
+	// call we make, so by the time fromCtyValue returns it is likely to have
+	// unused capacity on the end of it, depending on how deeply-recursive
+	// the given cty.Value is.
+	path := make(cty.Path, 0)
+	return fromCtyValue(val, tVal, path)
+}
+
+func fromCtyValue(val cty.Value, target reflect.Value, path cty.Path) error {
+	ty := val.Type()
+
+	deepTarget := fromCtyPopulatePtr(target, false)
+
+	// If we're decoding into a cty.Value then we just pass through the
+	// value as-is, to enable partial decoding. This is the only situation
+	// where unknown values are permitted.
+	if deepTarget.Kind() == reflect.Struct && deepTarget.Type().AssignableTo(valueType) {
+		deepTarget.Set(reflect.ValueOf(val))
+		return nil
+	}
+
+	// Lists and maps can be nil without indirection, but everything else
+	// requires a pointer and we set it immediately to nil.
+	// We also make an exception for capsule types because we want to handle
+	// pointers specially for these.
+	// (fromCtyList and fromCtyMap must therefore deal with val.IsNull, while
+	// other types can assume no nulls after this point.)
+	if val.IsNull() && !val.Type().IsListType() && !val.Type().IsMapType() && !val.Type().IsCapsuleType() {
+		target = fromCtyPopulatePtr(target, true)
+		if target.Kind() != reflect.Ptr {
+			return path.NewErrorf("null value is not allowed")
+		}
+
+		target.Set(reflect.Zero(target.Type()))
+		return nil
+	}
+
+	target = deepTarget
+
+	if !val.IsKnown() {
+		return path.NewErrorf("value must be known")
+	}
+
+	switch ty {
+	case cty.Bool:
+		return fromCtyBool(val, target, path)
+	case cty.Number:
+		return fromCtyNumber(val, target, path)
+	case cty.String:
+		return fromCtyString(val, target, path)
+	}
+
+	switch {
+	case ty.IsListType():
+		return fromCtyList(val, target, path)
+	case ty.IsMapType():
+		return fromCtyMap(val, target, path)
+	case ty.IsSetType():
+		return fromCtySet(val, target, path)
+	case ty.IsObjectType():
+		return fromCtyObject(val, target, path)
+	case ty.IsTupleType():
+		return fromCtyTuple(val, target, path)
+	case ty.IsCapsuleType():
+		return fromCtyCapsule(val, target, path)
+	}
+
+	// We should never fall out here; reaching here indicates a bug in this
+	// function.
+	return path.NewErrorf("unsupported source type %#v", ty)
+}
+
+func fromCtyBool(val cty.Value, target reflect.Value, path cty.Path) error {
+	switch target.Kind() {
+
+	case reflect.Bool:
+		if val.True() {
+			target.Set(reflect.ValueOf(true))
+		} else {
+			target.Set(reflect.ValueOf(false))
+		}
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyNumber(val cty.Value, target reflect.Value, path cty.Path) error {
+	bf := val.AsBigFloat()
+
+	switch target.Kind() {
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return fromCtyNumberInt(bf, target, path)
+
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return fromCtyNumberUInt(bf, target, path)
+
+	case reflect.Float32, reflect.Float64:
+		return fromCtyNumberFloat(bf, target, path)
+
+	case reflect.Struct:
+		return fromCtyNumberBig(bf, target, path)
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyNumberInt(bf *big.Float, target reflect.Value, path cty.Path) error {
+	// Doing this with switch rather than << arithmetic because << with
+	// result >32-bits is not portable to 32-bit systems.
+	var min int64
+	var max int64
+	switch target.Type().Bits() {
+	case 8:
+		min = math.MinInt8
+		max = math.MaxInt8
+	case 16:
+		min = math.MinInt16
+		max = math.MaxInt16
+	case 32:
+		min = math.MinInt32
+		max = math.MaxInt32
+	case 64:
+		min = math.MinInt64
+		max = math.MaxInt64
+	default:
+		panic("weird number of bits in target int")
+	}
+
+	iv, accuracy := bf.Int64()
+	if accuracy != big.Exact || iv < min || iv > max {
+		return path.NewErrorf("value must be a whole number, between %d and %d", min, max)
+	}
+
+	target.Set(reflect.ValueOf(iv).Convert(target.Type()))
+
+	return nil
+}
+
+func fromCtyNumberUInt(bf *big.Float, target reflect.Value, path cty.Path) error {
+	// Doing this with switch rather than << arithmetic because << with
+	// result >32-bits is not portable to 32-bit systems.
+	var max uint64
+	switch target.Type().Bits() {
+	case 8:
+		max = math.MaxUint8
+	case 16:
+		max = math.MaxUint16
+	case 32:
+		max = math.MaxUint32
+	case 64:
+		max = math.MaxUint64
+	default:
+		panic("weird number of bits in target uint")
+	}
+
+	iv, accuracy := bf.Uint64()
+	if accuracy != big.Exact || iv > max {
+		return path.NewErrorf("value must be a whole number, between 0 and %d inclusive", max)
+	}
+
+	target.Set(reflect.ValueOf(iv).Convert(target.Type()))
+
+	return nil
+}
+
+func fromCtyNumberFloat(bf *big.Float, target reflect.Value, path cty.Path) error {
+	switch target.Kind() {
+	case reflect.Float32:
+		fv, accuracy := bf.Float32()
+		if accuracy != big.Exact {
+			// We allow the precision to be truncated as part of our conversion,
+			// but we don't want to silently introduce infinities.
+			if math.IsInf(float64(fv), 0) {
+				return path.NewErrorf("value must be between %f and %f inclusive", -math.MaxFloat32, math.MaxFloat32)
+			}
+		}
+		target.Set(reflect.ValueOf(fv))
+		return nil
+	case reflect.Float64:
+		fv, accuracy := bf.Float64()
+		if accuracy != big.Exact {
+			// We allow the precision to be truncated as part of our conversion,
+			// but we don't want to silently introduce infinities.
+			if math.IsInf(fv, 0) {
+				return path.NewErrorf("value must be between %f and %f inclusive", -math.MaxFloat64, math.MaxFloat64)
+			}
+		}
+		target.Set(reflect.ValueOf(fv))
+		return nil
+	default:
+		panic("unsupported kind of float")
+	}
+}
+
+func fromCtyNumberBig(bf *big.Float, target reflect.Value, path cty.Path) error {
+	switch {
+
+	case bigFloatType.AssignableTo(target.Type()):
+		// Easy!
+		target.Set(reflect.ValueOf(bf).Elem())
+		return nil
+
+	case bigIntType.AssignableTo(target.Type()):
+		bi, accuracy := bf.Int(nil)
+		if accuracy != big.Exact {
+			return path.NewErrorf("value must be a whole number")
+		}
+		target.Set(reflect.ValueOf(bi).Elem())
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+	}
+}
+
+func fromCtyString(val cty.Value, target reflect.Value, path cty.Path) error {
+	switch target.Kind() {
+
+	case reflect.String:
+		target.Set(reflect.ValueOf(val.AsString()))
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyList(val cty.Value, target reflect.Value, path cty.Path) error {
+	switch target.Kind() {
+
+	case reflect.Slice:
+		if val.IsNull() {
+			target.Set(reflect.Zero(target.Type()))
+			return nil
+		}
+
+		length := val.LengthInt()
+		tv := reflect.MakeSlice(target.Type(), length, length)
+
+		path = append(path, nil)
+
+		i := 0
+		var err error
+		val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			targetElem := tv.Index(i)
+			err = fromCtyValue(val, targetElem, path)
+			if err != nil {
+				return true
+			}
+
+			i++
+			return false
+		})
+		if err != nil {
+			return err
+		}
+
+		path = path[:len(path)-1]
+
+		target.Set(tv)
+		return nil
+
+	case reflect.Array:
+		if val.IsNull() {
+			return path.NewErrorf("null value is not allowed")
+		}
+
+		length := val.LengthInt()
+		if length != target.Len() {
+			return path.NewErrorf("must be a list of length %d", target.Len())
+		}
+
+		path = append(path, nil)
+
+		i := 0
+		var err error
+		val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			targetElem := target.Index(i)
+			err = fromCtyValue(val, targetElem, path)
+			if err != nil {
+				return true
+			}
+
+			i++
+			return false
+		})
+		if err != nil {
+			return err
+		}
+
+		path = path[:len(path)-1]
+
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyMap(val cty.Value, target reflect.Value, path cty.Path) error {
+
+	switch target.Kind() {
+
+	case reflect.Map:
+		if val.IsNull() {
+			target.Set(reflect.Zero(target.Type()))
+			return nil
+		}
+
+		tv := reflect.MakeMap(target.Type())
+		et := target.Type().Elem()
+
+		path = append(path, nil)
+
+		var err error
+		val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+			path[len(path)-1] = cty.IndexStep{
+				Key: key,
+			}
+
+			ks := key.AsString()
+
+			targetElem := reflect.New(et)
+			err = fromCtyValue(val, targetElem, path)
+
+			tv.SetMapIndex(reflect.ValueOf(ks), targetElem.Elem())
+
+			return err != nil
+		})
+		if err != nil {
+			return err
+		}
+
+		path = path[:len(path)-1]
+
+		target.Set(tv)
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtySet(val cty.Value, target reflect.Value, path cty.Path) error {
+	switch target.Kind() {
+
+	case reflect.Slice:
+		if val.IsNull() {
+			target.Set(reflect.Zero(target.Type()))
+			return nil
+		}
+
+		length := val.LengthInt()
+		tv := reflect.MakeSlice(target.Type(), length, length)
+
+		i := 0
+		var err error
+		val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+			targetElem := tv.Index(i)
+			err = fromCtyValue(val, targetElem, path)
+			if err != nil {
+				return true
+			}
+
+			i++
+			return false
+		})
+		if err != nil {
+			return err
+		}
+
+		target.Set(tv)
+		return nil
+
+	case reflect.Array:
+		if val.IsNull() {
+			return path.NewErrorf("null value is not allowed")
+		}
+
+		length := val.LengthInt()
+		if length != target.Len() {
+			return path.NewErrorf("must be a set of length %d", target.Len())
+		}
+
+		i := 0
+		var err error
+		val.ForEachElement(func(key cty.Value, val cty.Value) bool {
+			targetElem := target.Index(i)
+			err = fromCtyValue(val, targetElem, path)
+			if err != nil {
+				return true
+			}
+
+			i++
+			return false
+		})
+		if err != nil {
+			return err
+		}
+
+		return nil
+
+	// TODO: decode into set.Set instance
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyObject(val cty.Value, target reflect.Value, path cty.Path) error {
+
+	switch target.Kind() {
+
+	case reflect.Struct:
+
+		attrTypes := val.Type().AttributeTypes()
+		targetFields := structTagIndices(target.Type())
+
+		path = append(path, nil)
+
+		for k, i := range targetFields {
+			if _, exists := attrTypes[k]; !exists {
+				// If the field in question isn't able to represent nil,
+				// that's an error.
+				fk := target.Field(i).Kind()
+				switch fk {
+				case reflect.Ptr, reflect.Slice, reflect.Map, reflect.Interface:
+					// okay
+				default:
+					return path.NewErrorf("missing required attribute %q", k)
+				}
+			}
+		}
+
+		for k := range attrTypes {
+			path[len(path)-1] = cty.GetAttrStep{
+				Name: k,
+			}
+
+			fieldIdx, exists := targetFields[k]
+			if !exists {
+				return path.NewErrorf("unsupported attribute %q", k)
+			}
+
+			ev := val.GetAttr(k)
+
+			targetField := target.Field(fieldIdx)
+			err := fromCtyValue(ev, targetField, path)
+			if err != nil {
+				return err
+			}
+		}
+
+		path = path[:len(path)-1]
+
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyTuple(val cty.Value, target reflect.Value, path cty.Path) error {
+
+	switch target.Kind() {
+
+	case reflect.Struct:
+
+		elemTypes := val.Type().TupleElementTypes()
+		fieldCount := target.Type().NumField()
+
+		if fieldCount != len(elemTypes) {
+			return path.NewErrorf("a tuple of %d elements is required", fieldCount)
+		}
+
+		path = append(path, nil)
+
+		for i := range elemTypes {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(i)),
+			}
+
+			ev := val.Index(cty.NumberIntVal(int64(i)))
+
+			targetField := target.Field(i)
+			err := fromCtyValue(ev, targetField, path)
+			if err != nil {
+				return err
+			}
+		}
+
+		path = path[:len(path)-1]
+
+		return nil
+
+	default:
+		return likelyRequiredTypesError(path, target)
+
+	}
+}
+
+func fromCtyCapsule(val cty.Value, target reflect.Value, path cty.Path) error {
+
+	if target.Kind() == reflect.Ptr {
+		// Walk through indirection until we get to the last pointer,
+		// which we might set to null below.
+		target = fromCtyPopulatePtr(target, true)
+
+		if val.IsNull() {
+			target.Set(reflect.Zero(target.Type()))
+			return nil
+		}
+
+		// Since a capsule contains a pointer to an object, we'll preserve
+		// that pointer on the way out and thus allow the caller to recover
+		// the original object, rather than a copy of it.
+
+		eType := val.Type().EncapsulatedType()
+
+		if !eType.AssignableTo(target.Elem().Type()) {
+			// Our interface contract promises that we won't expose Go
+			// implementation details in error messages, so we need to keep
+			// this vague. This can only arise if a calling application has
+			// more than one capsule type in play and a user mixes them up.
+			return path.NewErrorf("incorrect type %s", val.Type().FriendlyName())
+		}
+
+		target.Set(reflect.ValueOf(val.EncapsulatedValue()))
+
+		return nil
+	} else {
+		if val.IsNull() {
+			return path.NewErrorf("null value is not allowed")
+		}
+
+		// If our target isn't a pointer then we will attempt to copy
+		// the encapsulated value into it.
+
+		eType := val.Type().EncapsulatedType()
+
+		if !eType.AssignableTo(target.Type()) {
+			// Our interface contract promises that we won't expose Go
+			// implementation details in error messages, so we need to keep
+			// this vague. This can only arise if a calling application has
+			// more than one capsule type in play and a user mixes them up.
+			return path.NewErrorf("incorrect type %s", val.Type().FriendlyName())
+		}
+
+		// We know that EncapsulatedValue is always a pointer, so we
+		// can safely call .Elem on its reflect.Value.
+		target.Set(reflect.ValueOf(val.EncapsulatedValue()).Elem())
+
+		return nil
+	}
+
+}
+
+// fromCtyPopulatePtr recognizes when target is a pointer type and allocates
+// a value to assign to that pointer, which it returns.
+//
+// If the given value has multiple levels of indirection, like **int, these
+// will be processed in turn so that the return value is guaranteed to be
+// a non-pointer.
+//
+// As an exception, if decodingNull is true then the returned value will be
+// the final level of pointer, if any, so that the caller can assign it
+// as nil to represent a null value. If the given target value is not a pointer
+// at all then the returned value will be just the given target, so the caller
+// must test if the returned value is a pointer before trying to assign nil
+// to it.
+func fromCtyPopulatePtr(target reflect.Value, decodingNull bool) reflect.Value {
+	for {
+		if target.Kind() == reflect.Interface && !target.IsNil() {
+			e := target.Elem()
+			if e.Kind() == reflect.Ptr && !e.IsNil() && (!decodingNull || e.Elem().Kind() == reflect.Ptr) {
+				target = e
+			}
+		}
+
+		if target.Kind() != reflect.Ptr {
+			break
+		}
+
+		// Stop early if we're decodingNull and we've found our last indirection
+		if target.Elem().Kind() != reflect.Ptr && decodingNull && target.CanSet() {
+			break
+		}
+
+		if target.IsNil() {
+			target.Set(reflect.New(target.Type().Elem()))
+		}
+
+		target = target.Elem()
+	}
+	return target
+}
+
+// likelyRequiredTypesError returns an error that states which types are
+// acceptable by making some assumptions about what types we support for
+// each target Go kind. It's not a precise science but it allows us to return
+// an error message that is cty-user-oriented rather than Go-oriented.
+//
+// Generally these error messages should be a matter of last resort, since
+// the calling application should be validating user-provided value types
+// before decoding anyway.
+func likelyRequiredTypesError(path cty.Path, target reflect.Value) error {
+	switch target.Kind() {
+
+	case reflect.Bool:
+		return path.NewErrorf("bool value is required")
+
+	case reflect.String:
+		return path.NewErrorf("string value is required")
+
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		fallthrough
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		fallthrough
+	case reflect.Float32, reflect.Float64:
+		return path.NewErrorf("number value is required")
+
+	case reflect.Slice, reflect.Array:
+		return path.NewErrorf("list or set value is required")
+
+	case reflect.Map:
+		return path.NewErrorf("map or object value is required")
+
+	case reflect.Struct:
+		switch {
+
+		case target.Type().AssignableTo(bigFloatType) || target.Type().AssignableTo(bigIntType):
+			return path.NewErrorf("number value is required")
+
+		case target.Type().AssignableTo(setType):
+			return path.NewErrorf("set or list value is required")
+
+		default:
+			return path.NewErrorf("object or tuple value is required")
+
+		}
+
+	default:
+		// We should avoid getting into this path, since this error
+		// message is rather useless.
+		return path.NewErrorf("incorrect type")
+
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/gocty/type_implied.go b/vendor/github.com/zclconf/go-cty/cty/gocty/type_implied.go
new file mode 100644
index 000000000..ce4c8f1e9
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/gocty/type_implied.go
@@ -0,0 +1,108 @@
+package gocty
+
+import (
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+// ImpliedType takes an arbitrary Go value (as an interface{}) and attempts
+// to find a suitable cty.Type instance that could be used for a conversion
+// with ToCtyValue.
+//
+// This allows -- for simple situations at least -- types to be defined just
+// once in Go and the cty types derived from the Go types, but in the process
+// it makes some assumptions that may be undesirable so applications are
+// encouraged to build their cty types directly if exacting control is
+// required.
+//
+// Not all Go types can be represented as cty types, so an error may be
+// returned which is usually considered to be a bug in the calling program.
+// In particular, ImpliedType will never use capsule types in its returned
+// type, because it cannot know the capsule types supported by the calling
+// program.
+func ImpliedType(gv interface{}) (cty.Type, error) {
+	rt := reflect.TypeOf(gv)
+	var path cty.Path
+	return impliedType(rt, path)
+}
+
+func impliedType(rt reflect.Type, path cty.Path) (cty.Type, error) {
+	switch rt.Kind() {
+
+	case reflect.Ptr:
+		return impliedType(rt.Elem(), path)
+
+	// Primitive types
+	case reflect.Bool:
+		return cty.Bool, nil
+	case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64:
+		return cty.Number, nil
+	case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64:
+		return cty.Number, nil
+	case reflect.Float32, reflect.Float64:
+		return cty.Number, nil
+	case reflect.String:
+		return cty.String, nil
+
+	// Collection types
+	case reflect.Slice:
+		path := append(path, cty.IndexStep{Key: cty.UnknownVal(cty.Number)})
+		ety, err := impliedType(rt.Elem(), path)
+		if err != nil {
+			return cty.NilType, err
+		}
+		return cty.List(ety), nil
+	case reflect.Map:
+		if !stringType.AssignableTo(rt.Key()) {
+			return cty.NilType, path.NewErrorf("no cty.Type for %s (must have string keys)", rt)
+		}
+		path := append(path, cty.IndexStep{Key: cty.UnknownVal(cty.String)})
+		ety, err := impliedType(rt.Elem(), path)
+		if err != nil {
+			return cty.NilType, err
+		}
+		return cty.Map(ety), nil
+
+	// Structural types
+	case reflect.Struct:
+		return impliedStructType(rt, path)
+
+	default:
+		return cty.NilType, path.NewErrorf("no cty.Type for %s", rt)
+	}
+}
+
+func impliedStructType(rt reflect.Type, path cty.Path) (cty.Type, error) {
+	if valueType.AssignableTo(rt) {
+		// Special case: cty.Value represents cty.DynamicPseudoType, for
+		// type conformance checking.
+		return cty.DynamicPseudoType, nil
+	}
+
+	fieldIdxs := structTagIndices(rt)
+	if len(fieldIdxs) == 0 {
+		return cty.NilType, path.NewErrorf("no cty.Type for %s (no cty field tags)", rt)
+	}
+
+	atys := make(map[string]cty.Type, len(fieldIdxs))
+
+	{
+		// Temporary extension of path for attributes
+		path := append(path, nil)
+
+		for k, fi := range fieldIdxs {
+			path[len(path)-1] = cty.GetAttrStep{Name: k}
+
+			ft := rt.Field(fi).Type
+			aty, err := impliedType(ft, path)
+			if err != nil {
+				return cty.NilType, err
+			}
+
+			atys[k] = aty
+		}
+	}
+
+	return cty.Object(atys), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/helper.go b/vendor/github.com/zclconf/go-cty/cty/helper.go
new file mode 100644
index 000000000..1b88e9fa0
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/helper.go
@@ -0,0 +1,99 @@
+package cty
+
+import (
+	"fmt"
+)
+
+// anyUnknown is a helper to easily check if a set of values contains any
+// unknowns, for operations that short-circuit to return unknown in that case.
+func anyUnknown(values ...Value) bool {
+	for _, val := range values {
+		if val.v == unknown {
+			return true
+		}
+	}
+	return false
+}
+
+// typeCheck tests whether all of the given values belong to the given type.
+// If the given types are a mixture of the given type and the dynamic
+// pseudo-type then a short-circuit dynamic value is returned. If the given
+// values are all of the correct type but at least one is unknown then
+// a short-circuit unknown value is returned. If any other types appear then
+// an error is returned. Otherwise (finally!) the result is nil, nil.
+func typeCheck(required Type, ret Type, values ...Value) (shortCircuit *Value, err error) {
+	hasDynamic := false
+	hasUnknown := false
+
+	for i, val := range values {
+		if val.ty == DynamicPseudoType {
+			hasDynamic = true
+			continue
+		}
+
+		if !val.Type().Equals(required) {
+			return nil, fmt.Errorf(
+				"type mismatch: want %s but value %d is %s",
+				required.FriendlyName(),
+				i, val.ty.FriendlyName(),
+			)
+		}
+
+		if val.v == unknown {
+			hasUnknown = true
+		}
+	}
+
+	if hasDynamic {
+		return &DynamicVal, nil
+	}
+
+	if hasUnknown {
+		ret := UnknownVal(ret)
+		return &ret, nil
+	}
+
+	return nil, nil
+}
+
+// mustTypeCheck is a wrapper around typeCheck that immediately panics if
+// any error is returned.
+func mustTypeCheck(required Type, ret Type, values ...Value) *Value {
+	shortCircuit, err := typeCheck(required, ret, values...)
+	if err != nil {
+		panic(err)
+	}
+	return shortCircuit
+}
+
+// shortCircuitForceType takes the return value from mustTypeCheck and
+// replaces it with an unknown of the given type if the original value was
+// DynamicVal.
+//
+// This is useful for operations that are specified to always return a
+// particular type, since then a dynamic result can safely be "upgrade" to
+// a strongly-typed unknown, which then allows subsequent operations to
+// be actually type-checked.
+//
+// It is safe to use this only if the operation in question is defined as
+// returning either a value of the given type or panicking, since we know
+// then that subsequent operations won't run if the operation panics.
+//
+// If the given short-circuit value is *not* DynamicVal then it must be
+// of the given type, or this function will panic.
+func forceShortCircuitType(shortCircuit *Value, ty Type) *Value {
+	if shortCircuit == nil {
+		return nil
+	}
+
+	if shortCircuit.ty == DynamicPseudoType {
+		ret := UnknownVal(ty)
+		return &ret
+	}
+
+	if !shortCircuit.ty.Equals(ty) {
+		panic("forceShortCircuitType got value of wrong type")
+	}
+
+	return shortCircuit
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json.go b/vendor/github.com/zclconf/go-cty/cty/json.go
new file mode 100644
index 000000000..c421a62ed
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json.go
@@ -0,0 +1,176 @@
+package cty
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+)
+
+// MarshalJSON is an implementation of json.Marshaler that allows Type
+// instances to be serialized as JSON.
+//
+// All standard types can be serialized, but capsule types cannot since there
+// is no way to automatically recover the original pointer and capsule types
+// compare by equality.
+func (t Type) MarshalJSON() ([]byte, error) {
+	switch impl := t.typeImpl.(type) {
+	case primitiveType:
+		switch impl.Kind {
+		case primitiveTypeBool:
+			return []byte{'"', 'b', 'o', 'o', 'l', '"'}, nil
+		case primitiveTypeNumber:
+			return []byte{'"', 'n', 'u', 'm', 'b', 'e', 'r', '"'}, nil
+		case primitiveTypeString:
+			return []byte{'"', 's', 't', 'r', 'i', 'n', 'g', '"'}, nil
+		default:
+			panic("unknown primitive type kind")
+		}
+	case typeList, typeMap, typeSet:
+		buf := &bytes.Buffer{}
+		etyJSON, err := t.ElementType().MarshalJSON()
+		if err != nil {
+			return nil, err
+		}
+		buf.WriteRune('[')
+		switch impl.(type) {
+		case typeList:
+			buf.WriteString(`"list"`)
+		case typeMap:
+			buf.WriteString(`"map"`)
+		case typeSet:
+			buf.WriteString(`"set"`)
+		}
+		buf.WriteRune(',')
+		buf.Write(etyJSON)
+		buf.WriteRune(']')
+		return buf.Bytes(), nil
+	case typeObject:
+		buf := &bytes.Buffer{}
+		atysJSON, err := json.Marshal(t.AttributeTypes())
+		if err != nil {
+			return nil, err
+		}
+		buf.WriteString(`["object",`)
+		buf.Write(atysJSON)
+		buf.WriteRune(']')
+		return buf.Bytes(), nil
+	case typeTuple:
+		buf := &bytes.Buffer{}
+		etysJSON, err := json.Marshal(t.TupleElementTypes())
+		if err != nil {
+			return nil, err
+		}
+		buf.WriteString(`["tuple",`)
+		buf.Write(etysJSON)
+		buf.WriteRune(']')
+		return buf.Bytes(), nil
+	case pseudoTypeDynamic:
+		return []byte{'"', 'd', 'y', 'n', 'a', 'm', 'i', 'c', '"'}, nil
+	case *capsuleType:
+		return nil, fmt.Errorf("type not allowed: %s", t.FriendlyName())
+	default:
+		// should never happen
+		panic("unknown type implementation")
+	}
+}
+
+// UnmarshalJSON is the opposite of MarshalJSON. See the documentation of
+// MarshalJSON for information on the limitations of JSON serialization of
+// types.
+func (t *Type) UnmarshalJSON(buf []byte) error {
+	r := bytes.NewReader(buf)
+	dec := json.NewDecoder(r)
+
+	tok, err := dec.Token()
+	if err != nil {
+		return err
+	}
+
+	switch v := tok.(type) {
+	case string:
+		switch v {
+		case "bool":
+			*t = Bool
+		case "number":
+			*t = Number
+		case "string":
+			*t = String
+		case "dynamic":
+			*t = DynamicPseudoType
+		default:
+			return fmt.Errorf("invalid primitive type name %q", v)
+		}
+
+		if dec.More() {
+			return fmt.Errorf("extraneous data after type description")
+		}
+		return nil
+	case json.Delim:
+		if rune(v) != '[' {
+			return fmt.Errorf("invalid complex type description")
+		}
+
+		tok, err = dec.Token()
+		if err != nil {
+			return err
+		}
+
+		kind, ok := tok.(string)
+		if !ok {
+			return fmt.Errorf("invalid complex type kind name")
+		}
+
+		switch kind {
+		case "list":
+			var ety Type
+			err = dec.Decode(&ety)
+			if err != nil {
+				return err
+			}
+			*t = List(ety)
+		case "map":
+			var ety Type
+			err = dec.Decode(&ety)
+			if err != nil {
+				return err
+			}
+			*t = Map(ety)
+		case "set":
+			var ety Type
+			err = dec.Decode(&ety)
+			if err != nil {
+				return err
+			}
+			*t = Set(ety)
+		case "object":
+			var atys map[string]Type
+			err = dec.Decode(&atys)
+			if err != nil {
+				return err
+			}
+			*t = Object(atys)
+		case "tuple":
+			var etys []Type
+			err = dec.Decode(&etys)
+			if err != nil {
+				return err
+			}
+			*t = Tuple(etys)
+		default:
+			return fmt.Errorf("invalid complex type kind name")
+		}
+
+		tok, err = dec.Token()
+		if err != nil {
+			return err
+		}
+		if delim, ok := tok.(json.Delim); !ok || rune(delim) != ']' || dec.More() {
+			return fmt.Errorf("unexpected extra data in type description")
+		}
+
+		return nil
+
+	default:
+		return fmt.Errorf("invalid type description")
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/doc.go b/vendor/github.com/zclconf/go-cty/cty/json/doc.go
new file mode 100644
index 000000000..8916513d6
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/doc.go
@@ -0,0 +1,11 @@
+// Package json provides functions for serializing cty types and values in
+// JSON format, and for decoding them again.
+//
+// Since the cty type system is a superset of the JSON type system,
+// round-tripping through JSON is lossy unless type information is provided
+// both at encoding time and decoding time. Callers of this package are
+// therefore suggested to define their expected structure as a cty.Type
+// and pass it in consistently both when encoding and when decoding, though
+// default (type-lossy) behavior is provided for situations where the precise
+// representation of the data is not significant.
+package json
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/marshal.go b/vendor/github.com/zclconf/go-cty/cty/json/marshal.go
new file mode 100644
index 000000000..f7bea1a2f
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/marshal.go
@@ -0,0 +1,189 @@
+package json
+
+import (
+	"bytes"
+	"encoding/json"
+	"sort"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+func marshal(val cty.Value, t cty.Type, path cty.Path, b *bytes.Buffer) error {
+	// If we're going to decode as DynamicPseudoType then we need to save
+	// dynamic type information to recover the real type.
+	if t == cty.DynamicPseudoType && val.Type() != cty.DynamicPseudoType {
+		return marshalDynamic(val, path, b)
+	}
+
+	if val.IsNull() {
+		b.WriteString("null")
+		return nil
+	}
+
+	if !val.IsKnown() {
+		return path.NewErrorf("value is not known")
+	}
+
+	// The caller should've guaranteed that the given val is conformant with
+	// the given type t, so we'll proceed under that assumption here.
+
+	switch {
+	case t.IsPrimitiveType():
+		switch t {
+		case cty.String:
+			json, err := json.Marshal(val.AsString())
+			if err != nil {
+				return path.NewErrorf("failed to serialize value: %s", err)
+			}
+			b.Write(json)
+			return nil
+		case cty.Number:
+			if val.RawEquals(cty.PositiveInfinity) || val.RawEquals(cty.NegativeInfinity) {
+				return path.NewErrorf("cannot serialize infinity as JSON")
+			}
+			b.WriteString(val.AsBigFloat().Text('f', -1))
+			return nil
+		case cty.Bool:
+			if val.True() {
+				b.WriteString("true")
+			} else {
+				b.WriteString("false")
+			}
+			return nil
+		default:
+			panic("unsupported primitive type")
+		}
+	case t.IsListType(), t.IsSetType():
+		b.WriteRune('[')
+		first := true
+		ety := t.ElementType()
+		it := val.ElementIterator()
+		path := append(path, nil) // local override of 'path' with extra element
+		for it.Next() {
+			if !first {
+				b.WriteRune(',')
+			}
+			ek, ev := it.Element()
+			path[len(path)-1] = cty.IndexStep{
+				Key: ek,
+			}
+			err := marshal(ev, ety, path, b)
+			if err != nil {
+				return err
+			}
+			first = false
+		}
+		b.WriteRune(']')
+		return nil
+	case t.IsMapType():
+		b.WriteRune('{')
+		first := true
+		ety := t.ElementType()
+		it := val.ElementIterator()
+		path := append(path, nil) // local override of 'path' with extra element
+		for it.Next() {
+			if !first {
+				b.WriteRune(',')
+			}
+			ek, ev := it.Element()
+			path[len(path)-1] = cty.IndexStep{
+				Key: ek,
+			}
+			var err error
+			err = marshal(ek, ek.Type(), path, b)
+			if err != nil {
+				return err
+			}
+			b.WriteRune(':')
+			err = marshal(ev, ety, path, b)
+			if err != nil {
+				return err
+			}
+			first = false
+		}
+		b.WriteRune('}')
+		return nil
+	case t.IsTupleType():
+		b.WriteRune('[')
+		etys := t.TupleElementTypes()
+		it := val.ElementIterator()
+		path := append(path, nil) // local override of 'path' with extra element
+		i := 0
+		for it.Next() {
+			if i > 0 {
+				b.WriteRune(',')
+			}
+			ety := etys[i]
+			ek, ev := it.Element()
+			path[len(path)-1] = cty.IndexStep{
+				Key: ek,
+			}
+			err := marshal(ev, ety, path, b)
+			if err != nil {
+				return err
+			}
+			i++
+		}
+		b.WriteRune(']')
+		return nil
+	case t.IsObjectType():
+		b.WriteRune('{')
+		atys := t.AttributeTypes()
+		path := append(path, nil) // local override of 'path' with extra element
+
+		names := make([]string, 0, len(atys))
+		for k := range atys {
+			names = append(names, k)
+		}
+		sort.Strings(names)
+
+		for i, k := range names {
+			aty := atys[k]
+			if i > 0 {
+				b.WriteRune(',')
+			}
+			av := val.GetAttr(k)
+			path[len(path)-1] = cty.GetAttrStep{
+				Name: k,
+			}
+			var err error
+			err = marshal(cty.StringVal(k), cty.String, path, b)
+			if err != nil {
+				return err
+			}
+			b.WriteRune(':')
+			err = marshal(av, aty, path, b)
+			if err != nil {
+				return err
+			}
+		}
+		b.WriteRune('}')
+		return nil
+	case t.IsCapsuleType():
+		rawVal := val.EncapsulatedValue()
+		jsonVal, err := json.Marshal(rawVal)
+		if err != nil {
+			return path.NewError(err)
+		}
+		b.Write(jsonVal)
+		return nil
+	default:
+		// should never happen
+		return path.NewErrorf("cannot JSON-serialize %s", t.FriendlyName())
+	}
+}
+
+// marshalDynamic adds an extra wrapping object containing dynamic type
+// information for the given value.
+func marshalDynamic(val cty.Value, path cty.Path, b *bytes.Buffer) error {
+	typeJSON, err := MarshalType(val.Type())
+	if err != nil {
+		return path.NewErrorf("failed to serialize type: %s", err)
+	}
+	b.WriteString(`{"value":`)
+	marshal(val, val.Type(), path, b)
+	b.WriteString(`,"type":`)
+	b.Write(typeJSON)
+	b.WriteRune('}')
+	return nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/simple.go b/vendor/github.com/zclconf/go-cty/cty/json/simple.go
new file mode 100644
index 000000000..507c9cc2c
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/simple.go
@@ -0,0 +1,41 @@
+package json
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// SimpleJSONValue is a wrapper around cty.Value that adds implementations of
+// json.Marshaler and json.Unmarshaler for simple-but-type-lossy automatic
+// encoding and decoding of values.
+//
+// The couplet Marshal and Unmarshal both take extra type information to
+// inform the encoding and decoding process so that all of the cty types
+// can be represented even though JSON's type system is a subset.
+//
+// SimpleJSONValue instead takes the approach of discarding the value's type
+// information and then deriving a new type from the stored structure when
+// decoding. This results in the same data being returned but not necessarily
+// with exactly the same type.
+//
+// For information on how types are inferred when decoding, see the
+// documentation of the function ImpliedType.
+type SimpleJSONValue struct {
+	cty.Value
+}
+
+// MarshalJSON is an implementation of json.Marshaler. See the documentation
+// of SimpleJSONValue for more information.
+func (v SimpleJSONValue) MarshalJSON() ([]byte, error) {
+	return Marshal(v.Value, v.Type())
+}
+
+// UnmarshalJSON is an implementation of json.Unmarshaler. See the
+// documentation of SimpleJSONValue for more information.
+func (v *SimpleJSONValue) UnmarshalJSON(buf []byte) error {
+	t, err := ImpliedType(buf)
+	if err != nil {
+		return err
+	}
+	v.Value, err = Unmarshal(buf, t)
+	return err
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/type.go b/vendor/github.com/zclconf/go-cty/cty/json/type.go
new file mode 100644
index 000000000..9131c6c77
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/type.go
@@ -0,0 +1,23 @@
+package json
+
+import (
+	"github.com/zclconf/go-cty/cty"
+)
+
+// MarshalType returns a JSON serialization of the given type.
+//
+// This is just a thin wrapper around t.MarshalJSON, for symmetry with
+// UnmarshalType.
+func MarshalType(t cty.Type) ([]byte, error) {
+	return t.MarshalJSON()
+}
+
+// UnmarshalType decodes a JSON serialization of the given type as produced
+// by either Type.MarshalJSON or MarshalType.
+//
+// This is a convenience wrapper around Type.UnmarshalJSON.
+func UnmarshalType(buf []byte) (cty.Type, error) {
+	var t cty.Type
+	err := t.UnmarshalJSON(buf)
+	return t, err
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go b/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go
new file mode 100644
index 000000000..1a973066e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/type_implied.go
@@ -0,0 +1,171 @@
+package json
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+
+	"github.com/zclconf/go-cty/cty"
+)
+
+// ImpliedType returns the cty Type implied by the structure of the given
+// JSON-compliant buffer. This function implements the default type mapping
+// behavior used when decoding arbitrary JSON without explicit cty Type
+// information.
+//
+// The rules are as follows:
+//
+// JSON strings, numbers and bools map to their equivalent primitive type in
+// cty.
+//
+// JSON objects map to cty object types, with the attributes defined by the
+// object keys and the types of their values.
+//
+// JSON arrays map to cty tuple types, with the elements defined by the
+// types of the array members.
+//
+// Any nulls are typed as DynamicPseudoType, so callers of this function
+// must be prepared to deal with this. Callers that do not wish to deal with
+// dynamic typing should not use this function and should instead describe
+// their required types explicitly with a cty.Type instance when decoding.
+//
+// Any JSON syntax errors will be returned as an error, and the type will
+// be the invalid value cty.NilType.
+func ImpliedType(buf []byte) (cty.Type, error) {
+	r := bytes.NewReader(buf)
+	dec := json.NewDecoder(r)
+	dec.UseNumber()
+
+	ty, err := impliedType(dec)
+	if err != nil {
+		return cty.NilType, err
+	}
+
+	if dec.More() {
+		return cty.NilType, fmt.Errorf("extraneous data after JSON object")
+	}
+
+	return ty, nil
+}
+
+func impliedType(dec *json.Decoder) (cty.Type, error) {
+	tok, err := dec.Token()
+	if err != nil {
+		return cty.NilType, err
+	}
+
+	return impliedTypeForTok(tok, dec)
+}
+
+func impliedTypeForTok(tok json.Token, dec *json.Decoder) (cty.Type, error) {
+	if tok == nil {
+		return cty.DynamicPseudoType, nil
+	}
+
+	switch ttok := tok.(type) {
+	case bool:
+		return cty.Bool, nil
+
+	case json.Number:
+		return cty.Number, nil
+
+	case string:
+		return cty.String, nil
+
+	case json.Delim:
+
+		switch rune(ttok) {
+		case '{':
+			return impliedObjectType(dec)
+		case '[':
+			return impliedTupleType(dec)
+		default:
+			return cty.NilType, fmt.Errorf("unexpected token %q", ttok)
+		}
+
+	default:
+		return cty.NilType, fmt.Errorf("unsupported JSON token %#v", tok)
+	}
+}
+
+func impliedObjectType(dec *json.Decoder) (cty.Type, error) {
+	// By the time we get in here, we've already consumed the { delimiter
+	// and so our next token should be the first object key.
+
+	var atys map[string]cty.Type
+
+	for {
+		// Read the object key first
+		tok, err := dec.Token()
+		if err != nil {
+			return cty.NilType, err
+		}
+
+		if ttok, ok := tok.(json.Delim); ok {
+			if rune(ttok) != '}' {
+				return cty.NilType, fmt.Errorf("unexpected delimiter %q", ttok)
+			}
+			break
+		}
+
+		key, ok := tok.(string)
+		if !ok {
+			return cty.NilType, fmt.Errorf("expected string but found %T", tok)
+		}
+
+		// Now read the value
+		tok, err = dec.Token()
+		if err != nil {
+			return cty.NilType, err
+		}
+
+		aty, err := impliedTypeForTok(tok, dec)
+		if err != nil {
+			return cty.NilType, err
+		}
+
+		if atys == nil {
+			atys = make(map[string]cty.Type)
+		}
+		atys[key] = aty
+	}
+
+	if len(atys) == 0 {
+		return cty.EmptyObject, nil
+	}
+
+	return cty.Object(atys), nil
+}
+
+func impliedTupleType(dec *json.Decoder) (cty.Type, error) {
+	// By the time we get in here, we've already consumed the { delimiter
+	// and so our next token should be the first value.
+
+	var etys []cty.Type
+
+	for {
+		tok, err := dec.Token()
+		if err != nil {
+			return cty.NilType, err
+		}
+
+		if ttok, ok := tok.(json.Delim); ok {
+			if rune(ttok) != ']' {
+				return cty.NilType, fmt.Errorf("unexpected delimiter %q", ttok)
+			}
+			break
+		}
+
+		ety, err := impliedTypeForTok(tok, dec)
+		if err != nil {
+			return cty.NilType, err
+		}
+		etys = append(etys, ety)
+	}
+
+	if len(etys) == 0 {
+		return cty.EmptyTuple, nil
+	}
+
+	return cty.Tuple(etys), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go b/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go
new file mode 100644
index 000000000..155f0b8a1
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/unmarshal.go
@@ -0,0 +1,459 @@
+package json
+
+import (
+	"bytes"
+	"encoding/json"
+	"fmt"
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+)
+
+func unmarshal(buf []byte, t cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+
+	tok, err := dec.Token()
+	if err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if tok == nil {
+		return cty.NullVal(t), nil
+	}
+
+	if t == cty.DynamicPseudoType {
+		return unmarshalDynamic(buf, path)
+	}
+
+	switch {
+	case t.IsPrimitiveType():
+		val, err := unmarshalPrimitive(tok, t, path)
+		if err != nil {
+			return cty.NilVal, err
+		}
+		return val, nil
+	case t.IsListType():
+		return unmarshalList(buf, t.ElementType(), path)
+	case t.IsSetType():
+		return unmarshalSet(buf, t.ElementType(), path)
+	case t.IsMapType():
+		return unmarshalMap(buf, t.ElementType(), path)
+	case t.IsTupleType():
+		return unmarshalTuple(buf, t.TupleElementTypes(), path)
+	case t.IsObjectType():
+		return unmarshalObject(buf, t.AttributeTypes(), path)
+	case t.IsCapsuleType():
+		return unmarshalCapsule(buf, t, path)
+	default:
+		return cty.NilVal, path.NewErrorf("unsupported type %s", t.FriendlyName())
+	}
+}
+
+func unmarshalPrimitive(tok json.Token, t cty.Type, path cty.Path) (cty.Value, error) {
+
+	switch t {
+	case cty.Bool:
+		switch v := tok.(type) {
+		case bool:
+			return cty.BoolVal(v), nil
+		case string:
+			val, err := convert.Convert(cty.StringVal(v), t)
+			if err != nil {
+				return cty.NilVal, path.NewError(err)
+			}
+			return val, nil
+		default:
+			return cty.NilVal, path.NewErrorf("bool is required")
+		}
+	case cty.Number:
+		if v, ok := tok.(json.Number); ok {
+			tok = string(v)
+		}
+		switch v := tok.(type) {
+		case string:
+			val, err := convert.Convert(cty.StringVal(v), t)
+			if err != nil {
+				return cty.NilVal, path.NewError(err)
+			}
+			return val, nil
+		default:
+			return cty.NilVal, path.NewErrorf("number is required")
+		}
+	case cty.String:
+		switch v := tok.(type) {
+		case string:
+			return cty.StringVal(v), nil
+		case json.Number:
+			return cty.StringVal(string(v)), nil
+		case bool:
+			val, err := convert.Convert(cty.BoolVal(v), t)
+			if err != nil {
+				return cty.NilVal, path.NewError(err)
+			}
+			return val, nil
+		default:
+			return cty.NilVal, path.NewErrorf("string is required")
+		}
+	default:
+		// should never happen
+		panic("unsupported primitive type")
+	}
+}
+
+func unmarshalList(buf []byte, ety cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '['); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	var vals []cty.Value
+
+	{
+		path := append(path, nil)
+		var idx int64
+
+		for dec.More() {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(idx),
+			}
+			idx++
+
+			rawVal, err := readRawValue(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read list value: %s", err)
+			}
+
+			el, err := unmarshal(rawVal, ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+
+			vals = append(vals, el)
+		}
+	}
+
+	if err := requireDelim(dec, ']'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if len(vals) == 0 {
+		return cty.ListValEmpty(ety), nil
+	}
+
+	return cty.ListVal(vals), nil
+}
+
+func unmarshalSet(buf []byte, ety cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '['); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	var vals []cty.Value
+
+	{
+		path := append(path, nil)
+
+		for dec.More() {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.UnknownVal(ety),
+			}
+
+			rawVal, err := readRawValue(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read set value: %s", err)
+			}
+
+			el, err := unmarshal(rawVal, ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+
+			vals = append(vals, el)
+		}
+	}
+
+	if err := requireDelim(dec, ']'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if len(vals) == 0 {
+		return cty.SetValEmpty(ety), nil
+	}
+
+	return cty.SetVal(vals), nil
+}
+
+func unmarshalMap(buf []byte, ety cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '{'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	vals := make(map[string]cty.Value)
+
+	{
+		path := append(path, nil)
+
+		for dec.More() {
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.UnknownVal(cty.String),
+			}
+
+			var err error
+
+			k, err := requireObjectKey(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read map key: %s", err)
+			}
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.StringVal(k),
+			}
+
+			rawVal, err := readRawValue(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read map value: %s", err)
+			}
+
+			el, err := unmarshal(rawVal, ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+
+			vals[k] = el
+		}
+	}
+
+	if err := requireDelim(dec, '}'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if len(vals) == 0 {
+		return cty.MapValEmpty(ety), nil
+	}
+
+	return cty.MapVal(vals), nil
+}
+
+func unmarshalTuple(buf []byte, etys []cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '['); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	var vals []cty.Value
+
+	{
+		path := append(path, nil)
+		var idx int
+
+		for dec.More() {
+			if idx >= len(etys) {
+				return cty.NilVal, path[:len(path)-1].NewErrorf("too many tuple elements (need %d)", len(etys))
+			}
+
+			path[len(path)-1] = cty.IndexStep{
+				Key: cty.NumberIntVal(int64(idx)),
+			}
+			ety := etys[idx]
+			idx++
+
+			rawVal, err := readRawValue(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read tuple value: %s", err)
+			}
+
+			el, err := unmarshal(rawVal, ety, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+
+			vals = append(vals, el)
+		}
+	}
+
+	if err := requireDelim(dec, ']'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if len(vals) != len(etys) {
+		return cty.NilVal, path[:len(path)-1].NewErrorf("not enough tuple elements (need %d)", len(etys))
+	}
+
+	if len(vals) == 0 {
+		return cty.EmptyTupleVal, nil
+	}
+
+	return cty.TupleVal(vals), nil
+}
+
+func unmarshalObject(buf []byte, atys map[string]cty.Type, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '{'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	vals := make(map[string]cty.Value)
+
+	{
+		objPath := path           // some errors report from the object's perspective
+		path := append(path, nil) // path to a specific attribute
+
+		for dec.More() {
+
+			var err error
+
+			k, err := requireObjectKey(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read object key: %s", err)
+			}
+
+			aty, ok := atys[k]
+			if !ok {
+				return cty.NilVal, objPath.NewErrorf("unsupported attribute %q", k)
+			}
+
+			path[len(path)-1] = cty.GetAttrStep{
+				Name: k,
+			}
+
+			rawVal, err := readRawValue(dec)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to read object value: %s", err)
+			}
+
+			el, err := unmarshal(rawVal, aty, path)
+			if err != nil {
+				return cty.NilVal, err
+			}
+
+			vals[k] = el
+		}
+	}
+
+	if err := requireDelim(dec, '}'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	// Make sure we have a value for every attribute
+	for k, aty := range atys {
+		if _, exists := vals[k]; !exists {
+			vals[k] = cty.NullVal(aty)
+		}
+	}
+
+	if len(vals) == 0 {
+		return cty.EmptyObjectVal, nil
+	}
+
+	return cty.ObjectVal(vals), nil
+}
+
+func unmarshalCapsule(buf []byte, t cty.Type, path cty.Path) (cty.Value, error) {
+	rawType := t.EncapsulatedType()
+	ptrPtr := reflect.New(reflect.PtrTo(rawType))
+	ptrPtr.Elem().Set(reflect.New(rawType))
+	ptr := ptrPtr.Elem().Interface()
+	err := json.Unmarshal(buf, ptr)
+	if err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	return cty.CapsuleVal(t, ptr), nil
+}
+
+func unmarshalDynamic(buf []byte, path cty.Path) (cty.Value, error) {
+	dec := bufDecoder(buf)
+	if err := requireDelim(dec, '{'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	var t cty.Type
+	var valBody []byte // defer actual decoding until we know the type
+
+	for dec.More() {
+		var err error
+
+		key, err := requireObjectKey(dec)
+		if err != nil {
+			return cty.NilVal, path.NewErrorf("failed to read dynamic type descriptor key: %s", err)
+		}
+
+		rawVal, err := readRawValue(dec)
+		if err != nil {
+			return cty.NilVal, path.NewErrorf("failed to read dynamic type descriptor value: %s", err)
+		}
+
+		switch key {
+		case "type":
+			err := json.Unmarshal(rawVal, &t)
+			if err != nil {
+				return cty.NilVal, path.NewErrorf("failed to decode type for dynamic value: %s", err)
+			}
+		case "value":
+			valBody = rawVal
+		default:
+			return cty.NilVal, path.NewErrorf("invalid key %q in dynamically-typed value", key)
+		}
+
+	}
+
+	if err := requireDelim(dec, '}'); err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+
+	if t == cty.NilType {
+		return cty.NilVal, path.NewErrorf("missing type in dynamically-typed value")
+	}
+	if valBody == nil {
+		return cty.NilVal, path.NewErrorf("missing value in dynamically-typed value")
+	}
+
+	val, err := Unmarshal([]byte(valBody), t)
+	if err != nil {
+		return cty.NilVal, path.NewError(err)
+	}
+	return val, nil
+}
+
+func requireDelim(dec *json.Decoder, d rune) error {
+	tok, err := dec.Token()
+	if err != nil {
+		return err
+	}
+
+	if tok != json.Delim(d) {
+		return fmt.Errorf("missing expected %c", d)
+	}
+
+	return nil
+}
+
+func requireObjectKey(dec *json.Decoder) (string, error) {
+	tok, err := dec.Token()
+	if err != nil {
+		return "", err
+	}
+	if s, ok := tok.(string); ok {
+		return s, nil
+	}
+	return "", fmt.Errorf("missing expected object key")
+}
+
+func readRawValue(dec *json.Decoder) ([]byte, error) {
+	var rawVal json.RawMessage
+	err := dec.Decode(&rawVal)
+	if err != nil {
+		return nil, err
+	}
+	return []byte(rawVal), nil
+}
+
+func bufDecoder(buf []byte) *json.Decoder {
+	r := bytes.NewReader(buf)
+	dec := json.NewDecoder(r)
+	dec.UseNumber()
+	return dec
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/json/value.go b/vendor/github.com/zclconf/go-cty/cty/json/value.go
new file mode 100644
index 000000000..f2f7dd56c
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/json/value.go
@@ -0,0 +1,65 @@
+package json
+
+import (
+	"bytes"
+
+	"github.com/zclconf/go-cty/cty"
+	"github.com/zclconf/go-cty/cty/convert"
+)
+
+// Marshal produces a JSON representation of the given value that can later
+// be decoded into a value of the given type.
+//
+// A type is specified separately to allow for the given type to include
+// cty.DynamicPseudoType to represent situations where any type is permitted
+// and so type information must be included to allow recovery of the stored
+// structure when decoding.
+//
+// The given type will also be used to attempt automatic conversions of any
+// non-conformant types in the given value, although this will not always
+// be possible. If the value cannot be made to be conformant then an error is
+// returned, which may be a cty.PathError.
+//
+// Capsule-typed values can be marshalled, but with some caveats. Since
+// capsule values are compared by pointer equality, it is impossible to recover
+// a value that will compare equal to the original value. Additionally,
+// it's not possible to JSON-serialize the capsule type itself, so it's not
+// valid to use capsule types within parts of the value that are conformed to
+// cty.DynamicPseudoType. Otherwise, a capsule value can be used as long as
+// the encapsulated type itself is serializable with the Marshal function
+// in encoding/json.
+func Marshal(val cty.Value, t cty.Type) ([]byte, error) {
+	errs := val.Type().TestConformance(t)
+	if errs != nil {
+		// Attempt a conversion
+		var err error
+		val, err = convert.Convert(val, t)
+		if err != nil {
+			return nil, err
+		}
+	}
+
+	// From this point onward, val can be assumed to be conforming to t.
+
+	buf := &bytes.Buffer{}
+	var path cty.Path
+	err := marshal(val, t, path, buf)
+
+	if err != nil {
+		return nil, err
+	}
+
+	return buf.Bytes(), nil
+}
+
+// Unmarshal decodes a JSON representation of the given value into a cty Value
+// conforming to the given type.
+//
+// While decoding, type conversions will be done where possible to make
+// the result conformant even if the types given in JSON are not exactly
+// correct. If conversion isn't possible then an error is returned, which
+// may be a cty.PathError.
+func Unmarshal(buf []byte, t cty.Type) (cty.Value, error) {
+	var path cty.Path
+	return unmarshal(buf, t, path)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/list_type.go b/vendor/github.com/zclconf/go-cty/cty/list_type.go
new file mode 100644
index 000000000..eadc865e5
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/list_type.go
@@ -0,0 +1,68 @@
+package cty
+
+import (
+	"fmt"
+)
+
+// TypeList instances represent specific list types. Each distinct ElementType
+// creates a distinct, non-equal list type.
+type typeList struct {
+	typeImplSigil
+	ElementTypeT Type
+}
+
+// List creates a map type with the given element Type.
+//
+// List types are CollectionType implementations.
+func List(elem Type) Type {
+	return Type{
+		typeList{
+			ElementTypeT: elem,
+		},
+	}
+}
+
+// Equals returns true if the other Type is a list whose element type is
+// equal to that of the receiver.
+func (t typeList) Equals(other Type) bool {
+	ot, isList := other.typeImpl.(typeList)
+	if !isList {
+		return false
+	}
+
+	return t.ElementTypeT.Equals(ot.ElementTypeT)
+}
+
+func (t typeList) FriendlyName() string {
+	return "list of " + t.ElementTypeT.FriendlyName()
+}
+
+func (t typeList) ElementType() Type {
+	return t.ElementTypeT
+}
+
+func (t typeList) GoString() string {
+	return fmt.Sprintf("cty.List(%#v)", t.ElementTypeT)
+}
+
+// IsListType returns true if the given type is a list type, regardless of its
+// element type.
+func (t Type) IsListType() bool {
+	_, ok := t.typeImpl.(typeList)
+	return ok
+}
+
+// ListElementType is a convenience method that checks if the given type is
+// a list type, returning a pointer to its element type if so and nil
+// otherwise. This is intended to allow convenient conditional branches,
+// like so:
+//
+//     if et := t.ListElementType(); et != nil {
+//         // Do something with *et
+//     }
+func (t Type) ListElementType() *Type {
+	if lt, ok := t.typeImpl.(typeList); ok {
+		return &lt.ElementTypeT
+	}
+	return nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/map_type.go b/vendor/github.com/zclconf/go-cty/cty/map_type.go
new file mode 100644
index 000000000..ae9abae04
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/map_type.go
@@ -0,0 +1,68 @@
+package cty
+
+import (
+	"fmt"
+)
+
+// TypeList instances represent specific list types. Each distinct ElementType
+// creates a distinct, non-equal list type.
+type typeMap struct {
+	typeImplSigil
+	ElementTypeT Type
+}
+
+// Map creates a map type with the given element Type.
+//
+// Map types are CollectionType implementations.
+func Map(elem Type) Type {
+	return Type{
+		typeMap{
+			ElementTypeT: elem,
+		},
+	}
+}
+
+// Equals returns true if the other Type is a map whose element type is
+// equal to that of the receiver.
+func (t typeMap) Equals(other Type) bool {
+	ot, isMap := other.typeImpl.(typeMap)
+	if !isMap {
+		return false
+	}
+
+	return t.ElementTypeT.Equals(ot.ElementTypeT)
+}
+
+func (t typeMap) FriendlyName() string {
+	return "map of " + t.ElementTypeT.FriendlyName()
+}
+
+func (t typeMap) ElementType() Type {
+	return t.ElementTypeT
+}
+
+func (t typeMap) GoString() string {
+	return fmt.Sprintf("cty.Map(%#v)", t.ElementTypeT)
+}
+
+// IsMapType returns true if the given type is a list type, regardless of its
+// element type.
+func (t Type) IsMapType() bool {
+	_, ok := t.typeImpl.(typeMap)
+	return ok
+}
+
+// MapElementType is a convenience method that checks if the given type is
+// a map type, returning a pointer to its element type if so and nil
+// otherwise. This is intended to allow convenient conditional branches,
+// like so:
+//
+//     if et := t.MapElementType(); et != nil {
+//         // Do something with *et
+//     }
+func (t Type) MapElementType() *Type {
+	if lt, ok := t.typeImpl.(typeMap); ok {
+		return &lt.ElementTypeT
+	}
+	return nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/null.go b/vendor/github.com/zclconf/go-cty/cty/null.go
new file mode 100644
index 000000000..d58d0287b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/null.go
@@ -0,0 +1,14 @@
+package cty
+
+// NullVal returns a null value of the given type. A null can be created of any
+// type, but operations on such values will always panic. Calling applications
+// are encouraged to use nulls only sparingly, particularly when user-provided
+// expressions are to be evaluated, since the precence of nulls creates a
+// much higher chance of evaluation errors that can't be caught by a type
+// checker.
+func NullVal(t Type) Value {
+	return Value{
+		ty: t,
+		v:  nil,
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/object_type.go b/vendor/github.com/zclconf/go-cty/cty/object_type.go
new file mode 100644
index 000000000..6f5ef3056
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/object_type.go
@@ -0,0 +1,128 @@
+package cty
+
+import (
+	"fmt"
+)
+
+type typeObject struct {
+	typeImplSigil
+	AttrTypes map[string]Type
+}
+
+// Object creates an object type with the given attribute types.
+//
+// After a map is passed to this function the caller must no longer access it,
+// since ownership is transferred to this library.
+func Object(attrTypes map[string]Type) Type {
+	return Type{
+		typeObject{
+			AttrTypes: attrTypes,
+		},
+	}
+}
+
+func (t typeObject) Equals(other Type) bool {
+	if ot, ok := other.typeImpl.(typeObject); ok {
+		if len(t.AttrTypes) != len(ot.AttrTypes) {
+			// Fast path: if we don't have the same number of attributes
+			// then we can't possibly be equal. This also avoids the need
+			// to test attributes in both directions below, since we know
+			// there can't be extras in "other".
+			return false
+		}
+
+		for attr, ty := range t.AttrTypes {
+			oty, ok := ot.AttrTypes[attr]
+			if !ok {
+				return false
+			}
+			if !oty.Equals(ty) {
+				return false
+			}
+		}
+
+		return true
+	}
+	return false
+}
+
+func (t typeObject) FriendlyName() string {
+	// There isn't really a friendly way to write an object type due to its
+	// complexity, so we'll just do something English-ish. Callers will
+	// probably want to make some extra effort to avoid ever printing out
+	// an object type FriendlyName in its entirety. For example, could
+	// produce an error message by diffing two object types and saying
+	// something like "Expected attribute foo to be string, but got number".
+	// TODO: Finish this
+	return "object"
+}
+
+func (t typeObject) GoString() string {
+	if len(t.AttrTypes) == 0 {
+		return "cty.EmptyObject"
+	}
+	return fmt.Sprintf("cty.Object(%#v)", t.AttrTypes)
+}
+
+// EmptyObject is a shorthand for Object(map[string]Type{}), to more
+// easily talk about the empty object type.
+var EmptyObject Type
+
+// EmptyObjectVal is the only possible non-null, non-unknown value of type
+// EmptyObject.
+var EmptyObjectVal Value
+
+func init() {
+	EmptyObject = Object(map[string]Type{})
+	EmptyObjectVal = Value{
+		ty: EmptyObject,
+		v:  map[string]interface{}{},
+	}
+}
+
+// IsObjectType returns true if the given type is an object type, regardless
+// of its element type.
+func (t Type) IsObjectType() bool {
+	_, ok := t.typeImpl.(typeObject)
+	return ok
+}
+
+// HasAttribute returns true if the receiver has an attribute with the given
+// name, regardless of its type. Will panic if the reciever isn't an object
+// type; use IsObjectType to determine whether this operation will succeed.
+func (t Type) HasAttribute(name string) bool {
+	if ot, ok := t.typeImpl.(typeObject); ok {
+		_, hasAttr := ot.AttrTypes[name]
+		return hasAttr
+	}
+	panic("HasAttribute on non-object Type")
+}
+
+// AttributeType returns the type of the attribute with the given name. Will
+// panic if the receiver is not an object type (use IsObjectType to confirm)
+// or if the object type has no such attribute (use HasAttribute to confirm).
+func (t Type) AttributeType(name string) Type {
+	if ot, ok := t.typeImpl.(typeObject); ok {
+		aty, hasAttr := ot.AttrTypes[name]
+		if !hasAttr {
+			panic("no such attribute")
+		}
+		return aty
+	}
+	panic("AttributeType on non-object Type")
+}
+
+// AttributeTypes returns a map from attribute names to their associated
+// types. Will panic if the receiver is not an object type (use IsObjectType
+// to confirm).
+//
+// The returned map is part of the internal state of the type, and is provided
+// for read access only. It is forbidden for any caller to modify the returned
+// map. For many purposes the attribute-related methods of Value are more
+// appropriate and more convenient to use.
+func (t Type) AttributeTypes() map[string]Type {
+	if ot, ok := t.typeImpl.(typeObject); ok {
+		return ot.AttrTypes
+	}
+	panic("AttributeTypes on non-object Type")
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/path.go b/vendor/github.com/zclconf/go-cty/cty/path.go
new file mode 100644
index 000000000..d38c2231c
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/path.go
@@ -0,0 +1,178 @@
+package cty
+
+import (
+	"errors"
+	"fmt"
+)
+
+// A Path is a sequence of operations to locate a nested value within a
+// data structure.
+//
+// The empty Path represents the given item. Any PathSteps within represent
+// taking a single step down into a data structure.
+//
+// Path has some convenience methods for gradually constructing a path,
+// but callers can also feel free to just produce a slice of PathStep manually
+// and convert to this type, which may be more appropriate in environments
+// where memory pressure is a concern.
+type Path []PathStep
+
+// PathStep represents a single step down into a data structure, as part
+// of a Path. PathStep is a closed interface, meaning that the only
+// permitted implementations are those within this package.
+type PathStep interface {
+	pathStepSigil() pathStepImpl
+	Apply(Value) (Value, error)
+}
+
+// embed pathImpl into a struct to declare it a PathStep implementation
+type pathStepImpl struct{}
+
+func (p pathStepImpl) pathStepSigil() pathStepImpl {
+	return p
+}
+
+// Index returns a new Path that is the reciever with an IndexStep appended
+// to the end.
+//
+// This is provided as a convenient way to construct paths, but each call
+// will create garbage so it should not be used where memory pressure is a
+// concern.
+func (p Path) Index(v Value) Path {
+	ret := make(Path, len(p)+1)
+	copy(ret, p)
+	ret[len(p)] = IndexStep{
+		Key: v,
+	}
+	return ret
+}
+
+// GetAttr returns a new Path that is the reciever with a GetAttrStep appended
+// to the end.
+//
+// This is provided as a convenient way to construct paths, but each call
+// will create garbage so it should not be used where memory pressure is a
+// concern.
+func (p Path) GetAttr(name string) Path {
+	ret := make(Path, len(p)+1)
+	copy(ret, p)
+	ret[len(p)] = GetAttrStep{
+		Name: name,
+	}
+	return ret
+}
+
+// Apply applies each of the steps in turn to successive values starting with
+// the given value, and returns the result. If any step returns an error,
+// the whole operation returns an error.
+func (p Path) Apply(val Value) (Value, error) {
+	var err error
+	for i, step := range p {
+		val, err = step.Apply(val)
+		if err != nil {
+			return NilVal, fmt.Errorf("at step %d: %s", i, err)
+		}
+	}
+	return val, nil
+}
+
+// LastStep applies the given path up to the last step and then returns
+// the resulting value and the final step.
+//
+// This is useful when dealing with assignment operations, since in that
+// case the *value* of the last step is not important (and may not, in fact,
+// present at all) and we care only about its location.
+//
+// Since LastStep applies all steps except the last, it will return errors
+// for those steps in the same way as Apply does.
+//
+// If the path has *no* steps then the returned PathStep will be nil,
+// representing that any operation should be applied directly to the
+// given value.
+func (p Path) LastStep(val Value) (Value, PathStep, error) {
+	var err error
+
+	if len(p) == 0 {
+		return val, nil, nil
+	}
+
+	journey := p[:len(p)-1]
+	val, err = journey.Apply(val)
+	if err != nil {
+		return NilVal, nil, err
+	}
+	return val, p[len(p)-1], nil
+}
+
+// Copy makes a shallow copy of the receiver. Often when paths are passed to
+// caller code they come with the constraint that they are valid only until
+// the caller returns, due to how they are constructed internally. Callers
+// can use Copy to conveniently produce a copy of the value that _they_ control
+// the validity of.
+func (p Path) Copy() Path {
+	ret := make(Path, len(p))
+	copy(ret, p)
+	return ret
+}
+
+// IndexStep is a Step implementation representing applying the index operation
+// to a value, which must be of either a list, map, or set type.
+//
+// When describing a path through a *type* rather than a concrete value,
+// the Key may be an unknown value, indicating that the step applies to
+// *any* key of the given type.
+//
+// When indexing into a set, the Key is actually the element being accessed
+// itself, since in sets elements are their own identity.
+type IndexStep struct {
+	pathStepImpl
+	Key Value
+}
+
+// Apply returns the value resulting from indexing the given value with
+// our key value.
+func (s IndexStep) Apply(val Value) (Value, error) {
+	switch s.Key.Type() {
+	case Number:
+		if !val.Type().IsListType() {
+			return NilVal, errors.New("not a list type")
+		}
+	case String:
+		if !val.Type().IsMapType() {
+			return NilVal, errors.New("not a map type")
+		}
+	default:
+		return NilVal, errors.New("key value not number or string")
+	}
+
+	has := val.HasIndex(s.Key)
+	if !has.IsKnown() {
+		return UnknownVal(val.Type().ElementType()), nil
+	}
+	if !has.True() {
+		return NilVal, errors.New("value does not have given index key")
+	}
+
+	return val.Index(s.Key), nil
+}
+
+// GetAttrStep is a Step implementation representing retrieving an attribute
+// from a value, which must be of an object type.
+type GetAttrStep struct {
+	pathStepImpl
+	Name string
+}
+
+// Apply returns the value of our named attribute from the given value, which
+// must be of an object type that has a value of that name.
+func (s GetAttrStep) Apply(val Value) (Value, error) {
+	if !val.Type().IsObjectType() {
+		return NilVal, errors.New("not an object type")
+	}
+
+	if !val.Type().HasAttribute(s.Name) {
+		return NilVal, fmt.Errorf("object has no attribute %q", s.Name)
+	}
+
+	return val.GetAttr(s.Name), nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/primitive_type.go b/vendor/github.com/zclconf/go-cty/cty/primitive_type.go
new file mode 100644
index 000000000..b8682dd3d
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/primitive_type.go
@@ -0,0 +1,122 @@
+package cty
+
+import "math/big"
+
+// primitiveType is the hidden implementation of the various primitive types
+// that are exposed as variables in this package.
+type primitiveType struct {
+	typeImplSigil
+	Kind primitiveTypeKind
+}
+
+type primitiveTypeKind byte
+
+const (
+	primitiveTypeBool   primitiveTypeKind = 'B'
+	primitiveTypeNumber primitiveTypeKind = 'N'
+	primitiveTypeString primitiveTypeKind = 'S'
+)
+
+func (t primitiveType) Equals(other Type) bool {
+	if otherP, ok := other.typeImpl.(primitiveType); ok {
+		return otherP.Kind == t.Kind
+	}
+	return false
+}
+
+func (t primitiveType) FriendlyName() string {
+	switch t.Kind {
+	case primitiveTypeBool:
+		return "bool"
+	case primitiveTypeNumber:
+		return "number"
+	case primitiveTypeString:
+		return "string"
+	default:
+		// should never happen
+		panic("invalid primitive type")
+	}
+}
+
+func (t primitiveType) GoString() string {
+	switch t.Kind {
+	case primitiveTypeBool:
+		return "cty.Bool"
+	case primitiveTypeNumber:
+		return "cty.Number"
+	case primitiveTypeString:
+		return "cty.String"
+	default:
+		// should never happen
+		panic("invalid primitive type")
+	}
+}
+
+// Number is the numeric type. Number values are arbitrary-precision
+// decimal numbers, which can then be converted into Go's various numeric
+// types only if they are in the appropriate range.
+var Number Type
+
+// String is the string type. String values are sequences of unicode codepoints
+// encoded internally as UTF-8.
+var String Type
+
+// Bool is the boolean type. The two values of this type are True and False.
+var Bool Type
+
+// True is the truthy value of type Bool
+var True Value
+
+// False is the falsey value of type Bool
+var False Value
+
+// Zero is a number value representing exactly zero.
+var Zero Value
+
+// PositiveInfinity is a Number value representing positive infinity
+var PositiveInfinity Value
+
+// NegativeInfinity is a Number value representing negative infinity
+var NegativeInfinity Value
+
+func init() {
+	Number = Type{
+		primitiveType{Kind: primitiveTypeNumber},
+	}
+	String = Type{
+		primitiveType{Kind: primitiveTypeString},
+	}
+	Bool = Type{
+		primitiveType{Kind: primitiveTypeBool},
+	}
+	True = Value{
+		ty: Bool,
+		v:  true,
+	}
+	False = Value{
+		ty: Bool,
+		v:  false,
+	}
+	Zero = Value{
+		ty: Number,
+		v:  big.NewFloat(0),
+	}
+	PositiveInfinity = Value{
+		ty: Number,
+		v:  (&big.Float{}).SetInf(false),
+	}
+	NegativeInfinity = Value{
+		ty: Number,
+		v:  (&big.Float{}).SetInf(true),
+	}
+}
+
+// IsPrimitiveType returns true if and only if the reciever is a primitive
+// type, which means it's either number, string, or bool. Any two primitive
+// types can be safely compared for equality using the standard == operator
+// without panic, which is not a guarantee that holds for all types. Primitive
+// types can therefore also be used in switch statements.
+func (t Type) IsPrimitiveType() bool {
+	_, ok := t.typeImpl.(primitiveType)
+	return ok
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/gob.go b/vendor/github.com/zclconf/go-cty/cty/set/gob.go
new file mode 100644
index 000000000..da2978f65
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set/gob.go
@@ -0,0 +1,76 @@
+package set
+
+import (
+	"bytes"
+	"encoding/gob"
+	"fmt"
+)
+
+// GobEncode is an implementation of the interface gob.GobEncoder, allowing
+// sets to be included in structures encoded via gob.
+//
+// The set rules are included in the serialized value, so the caller must
+// register its concrete rules type with gob.Register before using a
+// set in a gob, and possibly also implement GobEncode/GobDecode to customize
+// how any parameters are persisted.
+//
+// The set elements are also included, so if they are of non-primitive types
+// they too must be registered with gob.
+//
+// If the produced gob values will persist for a long time, the caller must
+// ensure compatibility of the rules implementation. In particular, if the
+// definition of element equivalence changes between encoding and decoding
+// then two distinct stored elements may be considered equivalent on decoding,
+// causing the recovered set to have fewer elements than when it was stored.
+func (s Set) GobEncode() ([]byte, error) {
+	gs := gobSet{
+		Version: 0,
+		Rules:   s.rules,
+		Values:  s.Values(),
+	}
+
+	buf := &bytes.Buffer{}
+	enc := gob.NewEncoder(buf)
+	err := enc.Encode(gs)
+	if err != nil {
+		return nil, fmt.Errorf("error encoding set.Set: %s", err)
+	}
+
+	return buf.Bytes(), nil
+}
+
+// GobDecode is the opposite of GobEncode. See GobEncode for information
+// on the requirements for and caveats of including set values in gobs.
+func (s *Set) GobDecode(buf []byte) error {
+	r := bytes.NewReader(buf)
+	dec := gob.NewDecoder(r)
+
+	var gs gobSet
+	err := dec.Decode(&gs)
+	if err != nil {
+		return fmt.Errorf("error decoding set.Set: %s", err)
+	}
+	if gs.Version != 0 {
+		return fmt.Errorf("unsupported set.Set encoding version %d; need 0", gs.Version)
+	}
+
+	victim := NewSetFromSlice(gs.Rules, gs.Values)
+	s.vals = victim.vals
+	s.rules = victim.rules
+	return nil
+}
+
+type gobSet struct {
+	Version int
+	Rules   Rules
+
+	// The bucket-based representation is for efficient in-memory access, but
+	// for serialization it's enough to just retain the values themselves,
+	// which we can re-bucket using the rules (which may have changed!) when
+	// we re-inflate.
+	Values []interface{}
+}
+
+func init() {
+	gob.Register([]interface{}(nil))
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/iterator.go b/vendor/github.com/zclconf/go-cty/cty/set/iterator.go
new file mode 100644
index 000000000..f15498e2f
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set/iterator.go
@@ -0,0 +1,36 @@
+package set
+
+type Iterator struct {
+	bucketIds []int
+	vals      map[int][]interface{}
+	bucketIdx int
+	valIdx    int
+}
+
+func (it *Iterator) Value() interface{} {
+	return it.currentBucket()[it.valIdx]
+}
+
+func (it *Iterator) Next() bool {
+	if it.bucketIdx == -1 {
+		// init
+		if len(it.bucketIds) == 0 {
+			return false
+		}
+
+		it.valIdx = 0
+		it.bucketIdx = 0
+		return true
+	}
+
+	it.valIdx++
+	if it.valIdx >= len(it.currentBucket()) {
+		it.valIdx = 0
+		it.bucketIdx++
+	}
+	return it.bucketIdx < len(it.bucketIds)
+}
+
+func (it *Iterator) currentBucket() []interface{} {
+	return it.vals[it.bucketIds[it.bucketIdx]]
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/ops.go b/vendor/github.com/zclconf/go-cty/cty/set/ops.go
new file mode 100644
index 000000000..e900eb0ec
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set/ops.go
@@ -0,0 +1,189 @@
+package set
+
+import (
+	"sort"
+)
+
+// Add inserts the given value into the receiving Set.
+//
+// This mutates the set in-place. This operation is not thread-safe.
+func (s Set) Add(val interface{}) {
+	hv := s.rules.Hash(val)
+	if _, ok := s.vals[hv]; !ok {
+		s.vals[hv] = make([]interface{}, 0, 1)
+	}
+	bucket := s.vals[hv]
+
+	// See if an equivalent value is already present
+	for _, ev := range bucket {
+		if s.rules.Equivalent(val, ev) {
+			return
+		}
+	}
+
+	s.vals[hv] = append(bucket, val)
+}
+
+// Remove deletes the given value from the receiving set, if indeed it was
+// there in the first place. If the value is not present, this is a no-op.
+func (s Set) Remove(val interface{}) {
+	hv := s.rules.Hash(val)
+	bucket, ok := s.vals[hv]
+	if !ok {
+		return
+	}
+
+	for i, ev := range bucket {
+		if s.rules.Equivalent(val, ev) {
+			newBucket := make([]interface{}, 0, len(bucket)-1)
+			newBucket = append(newBucket, bucket[:i]...)
+			newBucket = append(newBucket, bucket[i+1:]...)
+			if len(newBucket) > 0 {
+				s.vals[hv] = newBucket
+			} else {
+				delete(s.vals, hv)
+			}
+			return
+		}
+	}
+}
+
+// Has returns true if the given value is in the receiving set, or false if
+// it is not.
+func (s Set) Has(val interface{}) bool {
+	hv := s.rules.Hash(val)
+	bucket, ok := s.vals[hv]
+	if !ok {
+		return false
+	}
+
+	for _, ev := range bucket {
+		if s.rules.Equivalent(val, ev) {
+			return true
+		}
+	}
+	return false
+}
+
+// Iterator returns an iterator over values in the set, in an undefined order
+// that callers should not depend on.
+//
+// The pattern for using the returned iterator is:
+//
+//     it := set.Iterator()
+//     for it.Next() {
+//         val := it.Value()
+//         // ...
+//     }
+//
+// Once an iterator has been created for a set, the set *must not* be mutated
+// until the iterator is no longer in use.
+func (s Set) Iterator() *Iterator {
+	// Sort the bucketIds to ensure that we always traverse in a
+	// consistent order.
+	bucketIds := make([]int, 0, len(s.vals))
+	for id := range s.vals {
+		bucketIds = append(bucketIds, id)
+	}
+	sort.Ints(bucketIds)
+
+	return &Iterator{
+		bucketIds: bucketIds,
+		vals:      s.vals,
+		bucketIdx: -1,
+	}
+}
+
+// EachValue calls the given callback once for each value in the set, in an
+// undefined order that callers should not depend on.
+func (s Set) EachValue(cb func(interface{})) {
+	it := s.Iterator()
+	for it.Next() {
+		cb(it.Value())
+	}
+}
+
+// Values returns a slice of all of the values in the set in no particular
+// order. This is just a wrapper around EachValue that accumulates the results
+// in a slice for caller convenience.
+//
+// The returned slice will be nil if there are no values in the set.
+func (s Set) Values() []interface{} {
+	var ret []interface{}
+	s.EachValue(func(v interface{}) {
+		ret = append(ret, v)
+	})
+	return ret
+}
+
+// Length returns the number of values in the set.
+func (s Set) Length() int {
+	var count int
+	for _, bucket := range s.vals {
+		count = count + len(bucket)
+	}
+	return count
+}
+
+// Union returns a new set that contains all of the members of both the
+// receiving set and the given set. Both sets must have the same rules, or
+// else this function will panic.
+func (s1 Set) Union(s2 Set) Set {
+	mustHaveSameRules(s1, s2)
+	rs := NewSet(s1.rules)
+	s1.EachValue(func(v interface{}) {
+		rs.Add(v)
+	})
+	s2.EachValue(func(v interface{}) {
+		rs.Add(v)
+	})
+	return rs
+}
+
+// Intersection returns a new set that contains the values that both the
+// receiver and given sets have in common. Both sets must have the same rules,
+// or else this function will panic.
+func (s1 Set) Intersection(s2 Set) Set {
+	mustHaveSameRules(s1, s2)
+	rs := NewSet(s1.rules)
+	s1.EachValue(func(v interface{}) {
+		if s2.Has(v) {
+			rs.Add(v)
+		}
+	})
+	return rs
+}
+
+// Subtract returns a new set that contains all of the values from the receiver
+// that are not also in the given set. Both sets must have the same rules,
+// or else this function will panic.
+func (s1 Set) Subtract(s2 Set) Set {
+	mustHaveSameRules(s1, s2)
+	rs := NewSet(s1.rules)
+	s1.EachValue(func(v interface{}) {
+		if !s2.Has(v) {
+			rs.Add(v)
+		}
+	})
+	return rs
+}
+
+// SymmetricDifference returns a new set that contains all of the values from
+// both the receiver and given sets, except those that both sets have in
+// common. Both sets must have the same rules, or else this function will
+// panic.
+func (s1 Set) SymmetricDifference(s2 Set) Set {
+	mustHaveSameRules(s1, s2)
+	rs := NewSet(s1.rules)
+	s1.EachValue(func(v interface{}) {
+		if !s2.Has(v) {
+			rs.Add(v)
+		}
+	})
+	s2.EachValue(func(v interface{}) {
+		if !s1.Has(v) {
+			rs.Add(v)
+		}
+	})
+	return rs
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/rules.go b/vendor/github.com/zclconf/go-cty/cty/set/rules.go
new file mode 100644
index 000000000..7200184b0
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set/rules.go
@@ -0,0 +1,25 @@
+package set
+
+// Rules represents the operations that define membership for a Set.
+//
+// Each Set has a Rules instance, whose methods must satisfy the interface
+// contracts given below for any value that will be added to the set.
+type Rules interface {
+	// Hash returns an int that somewhat-uniquely identifies the given value.
+	//
+	// A good hash function will minimize collisions for values that will be
+	// added to the set, though collisions *are* permitted. Collisions will
+	// simply reduce the efficiency of operations on the set.
+	Hash(interface{}) int
+
+	// Equivalent returns true if and only if the two values are considered
+	// equivalent for the sake of set membership. Two values that are
+	// equivalent cannot exist in the set at the same time, and if two
+	// equivalent values are added it is undefined which one will be
+	// returned when enumerating all of the set members.
+	//
+	// Two values that are equivalent *must* result in the same hash value,
+	// though it is *not* required that two values with the same hash value
+	// be equivalent.
+	Equivalent(interface{}, interface{}) bool
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set/set.go b/vendor/github.com/zclconf/go-cty/cty/set/set.go
new file mode 100644
index 000000000..b4fb316f1
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set/set.go
@@ -0,0 +1,62 @@
+package set
+
+import (
+	"fmt"
+)
+
+// Set is an implementation of the concept of a set: a collection where all
+// values are conceptually either in or out of the set, but the members are
+// not ordered.
+//
+// This type primarily exists to be the internal type of sets in cty, but
+// it is considered to be at the same level of abstraction as Go's built in
+// slice and map collection types, and so should make no cty-specific
+// assumptions.
+//
+// Set operations are not thread safe. It is the caller's responsibility to
+// provide mutex guarantees where necessary.
+//
+// Set operations are not optimized to minimize memory pressure. Mutating
+// a set will generally create garbage and so should perhaps be avoided in
+// tight loops where memory pressure is a concern.
+type Set struct {
+	vals  map[int][]interface{}
+	rules Rules
+}
+
+// NewSet returns an empty set with the membership rules given.
+func NewSet(rules Rules) Set {
+	return Set{
+		vals:  map[int][]interface{}{},
+		rules: rules,
+	}
+}
+
+func NewSetFromSlice(rules Rules, vals []interface{}) Set {
+	s := NewSet(rules)
+	for _, v := range vals {
+		s.Add(v)
+	}
+	return s
+}
+
+func sameRules(s1 Set, s2 Set) bool {
+	return s1.rules == s2.rules
+}
+
+func mustHaveSameRules(s1 Set, s2 Set) {
+	if !sameRules(s1, s2) {
+		panic(fmt.Errorf("incompatible set rules: %#v, %#v", s1.rules, s2.rules))
+	}
+}
+
+// HasRules returns true if and only if the receiving set has the given rules
+// instance as its rules.
+func (s Set) HasRules(rules Rules) bool {
+	return s.rules == rules
+}
+
+// Rules returns the receiving set's rules instance.
+func (s Set) Rules() Rules {
+	return s.rules
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set_internals.go b/vendor/github.com/zclconf/go-cty/cty/set_internals.go
new file mode 100644
index 000000000..ce738dbe6
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set_internals.go
@@ -0,0 +1,146 @@
+package cty
+
+import (
+	"bytes"
+	"fmt"
+	"hash/crc32"
+	"math/big"
+	"sort"
+)
+
+// setRules provides a Rules implementation for the ./set package that
+// respects the equality rules for cty values of the given type.
+//
+// This implementation expects that values added to the set will be
+// valid internal values for the given Type, which is to say that wrapping
+// the given value in a Value struct along with the ruleset's type should
+// produce a valid, working Value.
+type setRules struct {
+	Type Type
+}
+
+func (r setRules) Hash(v interface{}) int {
+	hashBytes := makeSetHashBytes(Value{
+		ty: r.Type,
+		v:  v,
+	})
+	return int(crc32.ChecksumIEEE(hashBytes))
+}
+
+func (r setRules) Equivalent(v1 interface{}, v2 interface{}) bool {
+	v1v := Value{
+		ty: r.Type,
+		v:  v1,
+	}
+	v2v := Value{
+		ty: r.Type,
+		v:  v2,
+	}
+
+	eqv := v1v.Equals(v2v)
+
+	// By comparing the result to true we ensure that an Unknown result,
+	// which will result if either value is unknown, will be considered
+	// as non-equivalent. Two unknown values are not equivalent for the
+	// sake of set membership.
+	return eqv.v == true
+}
+
+func makeSetHashBytes(val Value) []byte {
+	var buf bytes.Buffer
+	appendSetHashBytes(val, &buf)
+	return buf.Bytes()
+}
+
+func appendSetHashBytes(val Value, buf *bytes.Buffer) {
+	// Exactly what bytes we generate here don't matter as long as the following
+	// constraints hold:
+	// - Unknown and null values all generate distinct strings from
+	//   each other and from any normal value of the given type.
+	// - The delimiter used to separate items in a compound structure can
+	//   never appear literally in any of its elements.
+	// Since we don't support hetrogenous lists we don't need to worry about
+	// collisions between values of different types, apart from
+	// PseudoTypeDynamic.
+	// If in practice we *do* get a collision then it's not a big deal because
+	// the Equivalent function will still distinguish values, but set
+	// performance will be best if we are able to produce a distinct string
+	// for each distinct value, unknown values notwithstanding.
+	if !val.IsKnown() {
+		buf.WriteRune('?')
+		return
+	}
+	if val.IsNull() {
+		buf.WriteRune('~')
+		return
+	}
+
+	switch val.ty {
+	case Number:
+		buf.WriteString(val.v.(*big.Float).String())
+		return
+	case Bool:
+		if val.v.(bool) {
+			buf.WriteRune('T')
+		} else {
+			buf.WriteRune('F')
+		}
+		return
+	case String:
+		buf.WriteString(fmt.Sprintf("%q", val.v.(string)))
+		return
+	}
+
+	if val.ty.IsMapType() {
+		buf.WriteRune('{')
+		val.ForEachElement(func(keyVal, elementVal Value) bool {
+			appendSetHashBytes(keyVal, buf)
+			buf.WriteRune(':')
+			appendSetHashBytes(elementVal, buf)
+			buf.WriteRune(';')
+			return false
+		})
+		buf.WriteRune('}')
+		return
+	}
+
+	if val.ty.IsListType() || val.ty.IsSetType() {
+		buf.WriteRune('[')
+		val.ForEachElement(func(keyVal, elementVal Value) bool {
+			appendSetHashBytes(elementVal, buf)
+			buf.WriteRune(';')
+			return false
+		})
+		buf.WriteRune(']')
+		return
+	}
+
+	if val.ty.IsObjectType() {
+		buf.WriteRune('<')
+		attrNames := make([]string, 0, len(val.ty.AttributeTypes()))
+		for attrName := range val.ty.AttributeTypes() {
+			attrNames = append(attrNames, attrName)
+		}
+		sort.Strings(attrNames)
+		for _, attrName := range attrNames {
+			appendSetHashBytes(val.GetAttr(attrName), buf)
+			buf.WriteRune(';')
+		}
+		buf.WriteRune('>')
+		return
+	}
+
+	if val.ty.IsTupleType() {
+		buf.WriteRune('<')
+		val.ForEachElement(func(keyVal, elementVal Value) bool {
+			appendSetHashBytes(elementVal, buf)
+			buf.WriteRune(';')
+			return false
+		})
+		buf.WriteRune('>')
+		return
+	}
+
+	// should never get down here
+	panic("unsupported type in set hash")
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/set_type.go b/vendor/github.com/zclconf/go-cty/cty/set_type.go
new file mode 100644
index 000000000..952a2d2ba
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/set_type.go
@@ -0,0 +1,66 @@
+package cty
+
+import (
+	"fmt"
+)
+
+type typeSet struct {
+	typeImplSigil
+	ElementTypeT Type
+}
+
+// Set creates a set type with the given element Type.
+//
+// Set types are CollectionType implementations.
+func Set(elem Type) Type {
+	return Type{
+		typeSet{
+			ElementTypeT: elem,
+		},
+	}
+}
+
+// Equals returns true if the other Type is a set whose element type is
+// equal to that of the receiver.
+func (t typeSet) Equals(other Type) bool {
+	ot, isSet := other.typeImpl.(typeSet)
+	if !isSet {
+		return false
+	}
+
+	return t.ElementTypeT.Equals(ot.ElementTypeT)
+}
+
+func (t typeSet) FriendlyName() string {
+	return "set of " + t.ElementTypeT.FriendlyName()
+}
+
+func (t typeSet) ElementType() Type {
+	return t.ElementTypeT
+}
+
+func (t typeSet) GoString() string {
+	return fmt.Sprintf("cty.Set(%#v)", t.ElementTypeT)
+}
+
+// IsSetType returns true if the given type is a list type, regardless of its
+// element type.
+func (t Type) IsSetType() bool {
+	_, ok := t.typeImpl.(typeSet)
+	return ok
+}
+
+// SetElementType is a convenience method that checks if the given type is
+// a set type, returning a pointer to its element type if so and nil
+// otherwise. This is intended to allow convenient conditional branches,
+// like so:
+//
+//     if et := t.SetElementType(); et != nil {
+//         // Do something with *et
+//     }
+func (t Type) SetElementType() *Type {
+	if lt, ok := t.typeImpl.(typeSet); ok {
+		return &lt.ElementTypeT
+	}
+	return nil
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/tuple_type.go b/vendor/github.com/zclconf/go-cty/cty/tuple_type.go
new file mode 100644
index 000000000..b98349e3a
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/tuple_type.go
@@ -0,0 +1,121 @@
+package cty
+
+import (
+	"fmt"
+)
+
+type typeTuple struct {
+	typeImplSigil
+	ElemTypes []Type
+}
+
+// Tuple creates a tuple type with the given element types.
+//
+// After a slice is passed to this function the caller must no longer access
+// the underlying array, since ownership is transferred to this library.
+func Tuple(elemTypes []Type) Type {
+	return Type{
+		typeTuple{
+			ElemTypes: elemTypes,
+		},
+	}
+}
+
+func (t typeTuple) Equals(other Type) bool {
+	if ot, ok := other.typeImpl.(typeTuple); ok {
+		if len(t.ElemTypes) != len(ot.ElemTypes) {
+			// Fast path: if we don't have the same number of elements
+			// then we can't possibly be equal.
+			return false
+		}
+
+		for i, ty := range t.ElemTypes {
+			oty := ot.ElemTypes[i]
+			if !ok {
+				return false
+			}
+			if !oty.Equals(ty) {
+				return false
+			}
+		}
+
+		return true
+	}
+	return false
+}
+
+func (t typeTuple) FriendlyName() string {
+	// There isn't really a friendly way to write a tuple type due to its
+	// complexity, so we'll just do something English-ish. Callers will
+	// probably want to make some extra effort to avoid ever printing out
+	// a tuple type FriendlyName in its entirety. For example, could
+	// produce an error message by diffing two object types and saying
+	// something like "Expected attribute foo to be string, but got number".
+	// TODO: Finish this
+	return "tuple"
+}
+
+func (t typeTuple) GoString() string {
+	if len(t.ElemTypes) == 0 {
+		return "cty.EmptyTuple"
+	}
+	return fmt.Sprintf("cty.Tuple(%#v)", t.ElemTypes)
+}
+
+// EmptyTuple is a shorthand for Tuple([]Type{}), to more easily talk about
+// the empty tuple type.
+var EmptyTuple Type
+
+// EmptyTupleVal is the only possible non-null, non-unknown value of type
+// EmptyTuple.
+var EmptyTupleVal Value
+
+func init() {
+	EmptyTuple = Tuple([]Type{})
+	EmptyTupleVal = Value{
+		ty: EmptyTuple,
+		v:  []interface{}{},
+	}
+}
+
+// IsTupleType returns true if the given type is an object type, regardless
+// of its element type.
+func (t Type) IsTupleType() bool {
+	_, ok := t.typeImpl.(typeTuple)
+	return ok
+}
+
+// Length returns the number of elements of the receiving tuple type.
+// Will panic if the reciever isn't a tuple type; use IsTupleType to determine
+// whether this operation will succeed.
+func (t Type) Length() int {
+	if ot, ok := t.typeImpl.(typeTuple); ok {
+		return len(ot.ElemTypes)
+	}
+	panic("Length on non-tuple Type")
+}
+
+// TupleElementType returns the type of the element with the given index. Will
+// panic if the receiver is not a tuple type (use IsTupleType to confirm)
+// or if the index is out of range (use Length to confirm).
+func (t Type) TupleElementType(idx int) Type {
+	if ot, ok := t.typeImpl.(typeTuple); ok {
+		return ot.ElemTypes[idx]
+	}
+	panic("TupleElementType on non-tuple Type")
+}
+
+// TupleElementTypes returns a slice of the recieving tuple type's element
+// types. Will panic if the receiver is not a tuple type (use IsTupleType
+// to confirm).
+//
+// The returned slice is part of the internal state of the type, and is provided
+// for read access only. It is forbidden for any caller to modify the
+// underlying array. For many purposes the element-related methods of Value
+// are more appropriate and more convenient to use.
+func (t Type) TupleElementTypes() []Type {
+	if ot, ok := t.typeImpl.(typeTuple); ok {
+		return ot.ElemTypes
+	}
+	panic("TupleElementTypes on non-tuple Type")
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/type.go b/vendor/github.com/zclconf/go-cty/cty/type.go
new file mode 100644
index 000000000..ae5f1c83e
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/type.go
@@ -0,0 +1,95 @@
+package cty
+
+// Type represents value types within the type system.
+//
+// This is a closed interface type, meaning that only the concrete
+// implementations provided within this package are considered valid.
+type Type struct {
+	typeImpl
+}
+
+type typeImpl interface {
+	// isTypeImpl is a do-nothing method that exists only to express
+	// that a type is an implementation of typeImpl.
+	isTypeImpl() typeImplSigil
+
+	// Equals returns true if the other given Type exactly equals the
+	// receiver Type.
+	Equals(other Type) bool
+
+	// FriendlyName returns a human-friendly *English* name for the given
+	// type.
+	FriendlyName() string
+
+	// GoString implements the GoStringer interface from package fmt.
+	GoString() string
+}
+
+// Base implementation of Type to embed into concrete implementations
+// to signal that they are implementations of Type.
+type typeImplSigil struct{}
+
+func (t typeImplSigil) isTypeImpl() typeImplSigil {
+	return typeImplSigil{}
+}
+
+// Equals returns true if the other given Type exactly equals the receiver
+// type.
+func (t Type) Equals(other Type) bool {
+	return t.typeImpl.Equals(other)
+}
+
+// FriendlyName returns a human-friendly *English* name for the given type.
+func (t Type) FriendlyName() string {
+	return t.typeImpl.FriendlyName()
+}
+
+// GoString returns a string approximating how the receiver type would be
+// expressed in Go source code.
+func (t Type) GoString() string {
+	if t.typeImpl == nil {
+		return "cty.NilType"
+	}
+
+	return t.typeImpl.GoString()
+}
+
+// NilType is an invalid type used when a function is returning an error
+// and has no useful type to return. It should not be used and any methods
+// called on it will panic.
+var NilType = Type{}
+
+// HasDynamicTypes returns true either if the receiver is itself
+// DynamicPseudoType or if it is a compound type whose descendent elements
+// are DynamicPseudoType.
+func (t Type) HasDynamicTypes() bool {
+	switch {
+	case t == DynamicPseudoType:
+		return true
+	case t.IsPrimitiveType():
+		return false
+	case t.IsCollectionType():
+		return false
+	case t.IsObjectType():
+		attrTypes := t.AttributeTypes()
+		for _, at := range attrTypes {
+			if at.HasDynamicTypes() {
+				return true
+			}
+		}
+		return false
+	case t.IsTupleType():
+		elemTypes := t.TupleElementTypes()
+		for _, et := range elemTypes {
+			if et.HasDynamicTypes() {
+				return true
+			}
+		}
+		return false
+	case t.IsCapsuleType():
+		return false
+	default:
+		// Should never happen, since above should be exhaustive
+		panic("HasDynamicTypes does not support the given type")
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/type_conform.go b/vendor/github.com/zclconf/go-cty/cty/type_conform.go
new file mode 100644
index 000000000..b417dc79b
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/type_conform.go
@@ -0,0 +1,142 @@
+package cty
+
+// TestConformance recursively walks the receiver and the given other type and
+// returns nil if the receiver *conforms* to the given type.
+//
+// Type conformance is similar to type equality but has one crucial difference:
+// PseudoTypeDynamic can be used within the given type to represent that
+// *any* type is allowed.
+//
+// If any non-conformities are found, the returned slice will be non-nil and
+// contain at least one error value. It will be nil if the type is entirely
+// conformant.
+//
+// Note that the special behavior of PseudoTypeDynamic is the *only* exception
+// to normal type equality. Calling applications may wish to apply their own
+// automatic conversion logic to the given data structure to create a more
+// liberal notion of conformance to a type.
+//
+// Returned errors are usually (but not always) PathError instances that
+// indicate where in the structure the error was found. If a returned error
+// is of that type then the error message is written for (English-speaking)
+// end-users working within the cty type system, not mentioning any Go-oriented
+// implementation details.
+func (t Type) TestConformance(other Type) []error {
+	path := make(Path, 0)
+	var errs []error
+	testConformance(t, other, path, &errs)
+	return errs
+}
+
+func testConformance(given Type, want Type, path Path, errs *[]error) {
+	if want.Equals(DynamicPseudoType) {
+		// anything goes!
+		return
+	}
+
+	if given.Equals(want) {
+		// Any equal types are always conformant
+		return
+	}
+
+	// The remainder of this function is concerned with detecting
+	// and reporting the specific non-conformance, since we wouldn't
+	// have got here if the types were not divergent.
+	// We treat compound structures as special so that we can report
+	// specifically what is non-conforming, rather than simply returning
+	// the entire type names and letting the user puzzle it out.
+
+	if given.IsObjectType() && want.IsObjectType() {
+		givenAttrs := given.AttributeTypes()
+		wantAttrs := want.AttributeTypes()
+
+		if len(givenAttrs) != len(wantAttrs) {
+			// Something is missing from one of them.
+			for k := range givenAttrs {
+				if _, exists := wantAttrs[k]; !exists {
+					*errs = append(
+						*errs,
+						errorf(path, "unsupported attribute %q", k),
+					)
+				}
+			}
+			for k := range wantAttrs {
+				if _, exists := givenAttrs[k]; !exists {
+					*errs = append(
+						*errs,
+						errorf(path, "missing required attribute %q", k),
+					)
+				}
+			}
+		}
+
+		path = append(path, nil)
+		pathIdx := len(path) - 1
+
+		for k, wantAttrType := range wantAttrs {
+			if givenAttrType, exists := givenAttrs[k]; exists {
+				path[pathIdx] = GetAttrStep{Name: k}
+				testConformance(givenAttrType, wantAttrType, path, errs)
+			}
+		}
+
+		path = path[0:pathIdx]
+
+		return
+	}
+
+	if given.IsTupleType() && want.IsTupleType() {
+		givenElems := given.TupleElementTypes()
+		wantElems := want.TupleElementTypes()
+
+		if len(givenElems) != len(wantElems) {
+			*errs = append(
+				*errs,
+				errorf(path, "%d elements are required, but got %d", len(wantElems), len(givenElems)),
+			)
+			return
+		}
+
+		path = append(path, nil)
+		pathIdx := len(path) - 1
+
+		for i, wantElemType := range wantElems {
+			givenElemType := givenElems[i]
+			path[pathIdx] = IndexStep{Key: NumberIntVal(int64(i))}
+			testConformance(givenElemType, wantElemType, path, errs)
+		}
+
+		path = path[0:pathIdx]
+
+		return
+	}
+
+	if given.IsListType() && want.IsListType() {
+		path = append(path, IndexStep{Key: UnknownVal(Number)})
+		pathIdx := len(path) - 1
+		testConformance(given.ElementType(), want.ElementType(), path, errs)
+		path = path[0:pathIdx]
+		return
+	}
+
+	if given.IsMapType() && want.IsMapType() {
+		path = append(path, IndexStep{Key: UnknownVal(String)})
+		pathIdx := len(path) - 1
+		testConformance(given.ElementType(), want.ElementType(), path, errs)
+		path = path[0:pathIdx]
+		return
+	}
+
+	if given.IsSetType() && want.IsSetType() {
+		path = append(path, IndexStep{Key: UnknownVal(given.ElementType())})
+		pathIdx := len(path) - 1
+		testConformance(given.ElementType(), want.ElementType(), path, errs)
+		path = path[0:pathIdx]
+		return
+	}
+
+	*errs = append(
+		*errs,
+		errorf(path, "%s required, but received %s", want.FriendlyName(), given.FriendlyName()),
+	)
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/types_to_register.go b/vendor/github.com/zclconf/go-cty/cty/types_to_register.go
new file mode 100644
index 000000000..a6c4d51f8
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/types_to_register.go
@@ -0,0 +1,50 @@
+package cty
+
+import (
+	"encoding/gob"
+	"math/big"
+
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+// InternalTypesToRegister is a slice of values that covers all of the
+// internal types used in the representation of cty.Type and cty.Value
+// across all cty Types.
+//
+// This is intended to be used to register these types with encoding
+// packages that require registration of types used in interfaces, such as
+// encoding/gob, thus allowing cty types and values to be included in streams
+// created from those packages. However, registering with gob is not necessary
+// since that is done automatically as a side-effect of importing this package.
+//
+// Callers should not do anything with the values here except pass them on
+// verbatim to a registration function.
+//
+// If the calling application uses Capsule types that wrap local structs either
+// directly or indirectly, these structs may also need to be registered in
+// order to support encoding and decoding of values of these types. That is the
+// responsibility of the calling application.
+var InternalTypesToRegister []interface{}
+
+func init() {
+	InternalTypesToRegister = []interface{}{
+		primitiveType{},
+		typeList{},
+		typeMap{},
+		typeObject{},
+		typeSet{},
+		setRules{},
+		set.Set{},
+		typeTuple{},
+		big.Float{},
+		capsuleType{},
+		[]interface{}(nil),
+		map[string]interface{}(nil),
+	}
+
+	// Register these with gob here, rather than in gob.go, to ensure
+	// that this will always happen after we build the above.
+	for _, tv := range InternalTypesToRegister {
+		gob.Register(tv)
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/unknown.go b/vendor/github.com/zclconf/go-cty/cty/unknown.go
new file mode 100644
index 000000000..9f6fce99d
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/unknown.go
@@ -0,0 +1,79 @@
+package cty
+
+// unknownType is the placeholder type used for the sigil value representing
+// "Unknown", to make it unambigiously distinct from any other possible value.
+type unknownType struct {
+}
+
+// Unknown is a special value that can be
+var unknown interface{} = &unknownType{}
+
+// UnknownVal returns an Value that represents an unknown value of the given
+// type. Unknown values can be used to represent a value that is
+// not yet known. Its meaning is undefined in cty, but it could be used by
+// an calling application to allow partial evaluation.
+//
+// Unknown values of any type can be created of any type. All operations on
+// Unknown values themselves return Unknown.
+func UnknownVal(t Type) Value {
+	return Value{
+		ty: t,
+		v:  unknown,
+	}
+}
+
+func (t unknownType) GoString() string {
+	// This is the stringification of our internal unknown marker. The
+	// stringification of the public representation of unknowns is in
+	// Value.GoString.
+	return "cty.unknown"
+}
+
+type pseudoTypeDynamic struct {
+	typeImplSigil
+}
+
+// DynamicPseudoType represents the dynamic pseudo-type.
+//
+// This type can represent situations where a type is not yet known. Its
+// meaning is undefined in cty, but it could be used by a calling
+// application to allow expression type checking with some types not yet known.
+// For example, the application might optimistically permit any operation on
+// values of this type in type checking, allowing a partial type-check result,
+// and then repeat the check when more information is known to get the
+// final, concrete type.
+//
+// It is a pseudo-type because it is used only as a sigil to the calling
+// application. "Unknown" is the only valid value of this pseudo-type, so
+// operations on values of this type will always short-circuit as per
+// the rules for that special value.
+var DynamicPseudoType Type
+
+func (t pseudoTypeDynamic) Equals(other Type) bool {
+	_, ok := other.typeImpl.(pseudoTypeDynamic)
+	return ok
+}
+
+func (t pseudoTypeDynamic) FriendlyName() string {
+	return "dynamic"
+}
+
+func (t pseudoTypeDynamic) GoString() string {
+	return "cty.DynamicPseudoType"
+}
+
+// DynamicVal is the only valid value of the pseudo-type dynamic.
+// This value can be used as a placeholder where a value or expression's
+// type and value are both unknown, thus allowing partial evaluation. See
+// the docs for DynamicPseudoType for more information.
+var DynamicVal Value
+
+func init() {
+	DynamicPseudoType = Type{
+		pseudoTypeDynamic{},
+	}
+	DynamicVal = Value{
+		ty: DynamicPseudoType,
+		v:  unknown,
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/value.go b/vendor/github.com/zclconf/go-cty/cty/value.go
new file mode 100644
index 000000000..24ff35afd
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/value.go
@@ -0,0 +1,71 @@
+package cty
+
+// Value represents a value of a particular type, and is the interface by
+// which operations are executed on typed values.
+//
+// Value has two different classes of method. Operation methods stay entirely
+// within the type system (methods accept and return Value instances) and
+// are intended for use in implementing a language in terms of cty, while
+// integration methods either enter or leave the type system, working with
+// native Go values. Operation methods are guaranteed to support all of the
+// expected short-circuit behavior for unknown and dynamic values, while
+// integration methods may not.
+//
+// The philosophy for the operations API is that it's the caller's
+// responsibility to ensure that the given types and values satisfy the
+// specified invariants during a separate type check, so that the caller is
+// able to return errors to its user from the application's own perspective.
+//
+// Consequently the design of these methods assumes such checks have already
+// been done and panics if any invariants turn out not to be satisfied. These
+// panic errors are not intended to be handled, but rather indicate a bug in
+// the calling application that should be fixed with more checks prior to
+// executing operations.
+//
+// A related consequence of this philosophy is that no automatic type
+// conversions are done. If a method specifies that its argument must be
+// number then it's the caller's responsibility to do that conversion before
+// the call, thus allowing the application to have more constrained conversion
+// rules than are offered by the built-in converter where necessary.
+type Value struct {
+	ty Type
+	v  interface{}
+}
+
+// Type returns the type of the value.
+func (val Value) Type() Type {
+	return val.ty
+}
+
+// IsKnown returns true if the value is known. That is, if it is not
+// the result of the unknown value constructor Unknown(...), and is not
+// the result of an operation on another unknown value.
+//
+// Unknown values are only produced either directly or as a result of
+// operating on other unknown values, and so an application that never
+// introduces Unknown values can be guaranteed to never receive any either.
+func (val Value) IsKnown() bool {
+	return val.v != unknown
+}
+
+// IsNull returns true if the value is null. Values of any type can be
+// null, but any operations on a null value will panic. No operation ever
+// produces null, so an application that never introduces Null values can
+// be guaranteed to never receive any either.
+func (val Value) IsNull() bool {
+	return val.v == nil
+}
+
+// NilVal is an invalid Value that can be used as a placeholder when returning
+// with an error from a function that returns (Value, error).
+//
+// NilVal is *not* a valid error and so no operations may be performed on it.
+// Any attempt to use it will result in a panic.
+//
+// This should not be confused with the idea of a Null value, as returned by
+// NullVal. NilVal is a nil within the *Go* type system, and is invalid in
+// the cty type system. Null values *do* exist in the cty type system.
+var NilVal = Value{
+	ty: Type{typeImpl: nil},
+	v:  nil,
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/value_init.go b/vendor/github.com/zclconf/go-cty/cty/value_init.go
new file mode 100644
index 000000000..2ccafb1bf
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/value_init.go
@@ -0,0 +1,251 @@
+package cty
+
+import (
+	"fmt"
+	"math/big"
+	"reflect"
+
+	"golang.org/x/text/unicode/norm"
+
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+// BoolVal returns a Value of type Number whose internal value is the given
+// bool.
+func BoolVal(v bool) Value {
+	return Value{
+		ty: Bool,
+		v:  v,
+	}
+}
+
+// NumberVal returns a Value of type Number whose internal value is the given
+// big.Float. The returned value becomes the owner of the big.Float object,
+// and so it's forbidden for the caller to mutate the object after it's
+// wrapped in this way.
+func NumberVal(v *big.Float) Value {
+	return Value{
+		ty: Number,
+		v:  v,
+	}
+}
+
+// NumberIntVal returns a Value of type Number whose internal value is equal
+// to the given integer.
+func NumberIntVal(v int64) Value {
+	return NumberVal(new(big.Float).SetInt64(v))
+}
+
+// NumberUIntVal returns a Value of type Number whose internal value is equal
+// to the given unsigned integer.
+func NumberUIntVal(v uint64) Value {
+	return NumberVal(new(big.Float).SetUint64(v))
+}
+
+// NumberFloatVal returns a Value of type Number whose internal value is
+// equal to the given float.
+func NumberFloatVal(v float64) Value {
+	return NumberVal(new(big.Float).SetFloat64(v))
+}
+
+// StringVal returns a Value of type String whose internal value is the
+// given string.
+//
+// Strings must be UTF-8 encoded sequences of valid unicode codepoints, and
+// they are NFC-normalized on entry into the world of cty values.
+//
+// If the given string is not valid UTF-8 then behavior of string operations
+// is undefined.
+func StringVal(v string) Value {
+	return Value{
+		ty: String,
+		v:  norm.NFC.String(v),
+	}
+}
+
+// ObjectVal returns a Value of an object type whose structure is defined
+// by the key names and value types in the given map.
+func ObjectVal(attrs map[string]Value) Value {
+	attrTypes := make(map[string]Type, len(attrs))
+	attrVals := make(map[string]interface{}, len(attrs))
+
+	for attr, val := range attrs {
+		attrTypes[attr] = val.ty
+		attrVals[attr] = val.v
+	}
+
+	return Value{
+		ty: Object(attrTypes),
+		v:  attrVals,
+	}
+}
+
+// TupleVal returns a Value of a tuple type whose element types are
+// defined by the value types in the given slice.
+func TupleVal(elems []Value) Value {
+	elemTypes := make([]Type, len(elems))
+	elemVals := make([]interface{}, len(elems))
+
+	for i, val := range elems {
+		elemTypes[i] = val.ty
+		elemVals[i] = val.v
+	}
+
+	return Value{
+		ty: Tuple(elemTypes),
+		v:  elemVals,
+	}
+}
+
+// ListVal returns a Value of list type whose element type is defined by
+// the types of the given values, which must be homogenous.
+//
+// If the types are not all consistent (aside from elements that are of the
+// dynamic pseudo-type) then this function will panic. It will panic also
+// if the given list is empty, since then the element type cannot be inferred.
+// (See also ListValEmpty.)
+func ListVal(vals []Value) Value {
+	if len(vals) == 0 {
+		panic("must not call ListVal with empty slice")
+	}
+	elementType := DynamicPseudoType
+	rawList := make([]interface{}, len(vals))
+
+	for i, val := range vals {
+		if elementType == DynamicPseudoType {
+			elementType = val.ty
+		} else if val.ty != DynamicPseudoType && !elementType.Equals(val.ty) {
+			panic(fmt.Errorf(
+				"inconsistent list element types (%#v then %#v)",
+				elementType, val.ty,
+			))
+		}
+
+		rawList[i] = val.v
+	}
+
+	return Value{
+		ty: List(elementType),
+		v:  rawList,
+	}
+}
+
+// ListValEmpty returns an empty list of the given element type.
+func ListValEmpty(element Type) Value {
+	return Value{
+		ty: List(element),
+		v:  []interface{}{},
+	}
+}
+
+// MapVal returns a Value of a map type whose element type is defined by
+// the types of the given values, which must be homogenous.
+//
+// If the types are not all consistent (aside from elements that are of the
+// dynamic pseudo-type) then this function will panic. It will panic also
+// if the given map is empty, since then the element type cannot be inferred.
+// (See also MapValEmpty.)
+func MapVal(vals map[string]Value) Value {
+	if len(vals) == 0 {
+		panic("must not call MapVal with empty map")
+	}
+	elementType := DynamicPseudoType
+	rawMap := make(map[string]interface{}, len(vals))
+
+	for key, val := range vals {
+		if elementType == DynamicPseudoType {
+			elementType = val.ty
+		} else if val.ty != DynamicPseudoType && !elementType.Equals(val.ty) {
+			panic(fmt.Errorf(
+				"inconsistent map element types (%#v then %#v)",
+				elementType, val.ty,
+			))
+		}
+
+		rawMap[key] = val.v
+	}
+
+	return Value{
+		ty: Map(elementType),
+		v:  rawMap,
+	}
+}
+
+// MapValEmpty returns an empty map of the given element type.
+func MapValEmpty(element Type) Value {
+	return Value{
+		ty: Map(element),
+		v:  map[string]interface{}{},
+	}
+}
+
+// SetVal returns a Value of set type whose element type is defined by
+// the types of the given values, which must be homogenous.
+//
+// If the types are not all consistent (aside from elements that are of the
+// dynamic pseudo-type) then this function will panic. It will panic also
+// if the given list is empty, since then the element type cannot be inferred.
+// (See also SetValEmpty.)
+func SetVal(vals []Value) Value {
+	if len(vals) == 0 {
+		panic("must not call SetVal with empty slice")
+	}
+	elementType := DynamicPseudoType
+	rawList := make([]interface{}, len(vals))
+
+	for i, val := range vals {
+		if elementType == DynamicPseudoType {
+			elementType = val.ty
+		} else if val.ty != DynamicPseudoType && !elementType.Equals(val.ty) {
+			panic(fmt.Errorf(
+				"inconsistent set element types (%#v then %#v)",
+				elementType, val.ty,
+			))
+		}
+
+		rawList[i] = val.v
+	}
+
+	rawVal := set.NewSetFromSlice(setRules{elementType}, rawList)
+
+	return Value{
+		ty: Set(elementType),
+		v:  rawVal,
+	}
+}
+
+// SetValEmpty returns an empty set of the given element type.
+func SetValEmpty(element Type) Value {
+	return Value{
+		ty: Set(element),
+		v:  set.NewSet(setRules{element}),
+	}
+}
+
+// CapsuleVal creates a value of the given capsule type using the given
+// wrapVal, which must be a pointer to a value of the capsule type's native
+// type.
+//
+// This function will panic if the given type is not a capsule type, if
+// the given wrapVal is not compatible with the given capsule type, or if
+// wrapVal is not a pointer.
+func CapsuleVal(ty Type, wrapVal interface{}) Value {
+	if !ty.IsCapsuleType() {
+		panic("not a capsule type")
+	}
+
+	wv := reflect.ValueOf(wrapVal)
+	if wv.Kind() != reflect.Ptr {
+		panic("wrapVal is not a pointer")
+	}
+
+	it := ty.typeImpl.(*capsuleType).GoType
+	if !wv.Type().Elem().AssignableTo(it) {
+		panic("wrapVal target is not compatible with the given capsule type")
+	}
+
+	return Value{
+		ty: ty,
+		v:  wrapVal,
+	}
+}
diff --git a/vendor/github.com/zclconf/go-cty/cty/value_ops.go b/vendor/github.com/zclconf/go-cty/cty/value_ops.go
new file mode 100644
index 000000000..766e38ffc
--- /dev/null
+++ b/vendor/github.com/zclconf/go-cty/cty/value_ops.go
@@ -0,0 +1,976 @@
+package cty
+
+import (
+	"fmt"
+	"math/big"
+
+	"reflect"
+
+	"github.com/zclconf/go-cty/cty/set"
+)
+
+func (val Value) GoString() string {
+	if val == NilVal {
+		return "cty.NilVal"
+	}
+
+	if val.ty == DynamicPseudoType {
+		return "cty.DynamicValue"
+	}
+
+	if !val.IsKnown() {
+		return fmt.Sprintf("cty.Unknown(%#v)", val.ty)
+	}
+	if val.IsNull() {
+		return fmt.Sprintf("cty.Null(%#v)", val.ty)
+	}
+
+	// By the time we reach here we've dealt with all of the exceptions around
+	// unknowns and nulls, so we're guaranteed that the values are the
+	// canonical internal representation of the given type.
+
+	switch val.ty {
+	case Bool:
+		if val.v.(bool) {
+			return "cty.True"
+		} else {
+			return "cty.False"
+		}
+	case Number:
+		fv := val.v.(*big.Float)
+		// We'll try to use NumberIntVal or NumberFloatVal if we can, since
+		// the fully-general initializer call is pretty ugly-looking.
+		if fv.IsInt() {
+			return fmt.Sprintf("cty.NumberIntVal(%#v)", fv)
+		}
+		if rfv, accuracy := fv.Float64(); accuracy == big.Exact {
+			return fmt.Sprintf("cty.NumberFloatVal(%#v)", rfv)
+		}
+		return fmt.Sprintf("cty.NumberVal(new(big.Float).Parse(\"%#v\", 10))", fv)
+	case String:
+		return fmt.Sprintf("cty.StringVal(%#v)", val.v)
+	}
+
+	switch {
+	case val.ty.IsSetType():
+		vals := val.v.(set.Set).Values()
+		if vals == nil || len(vals) == 0 {
+			return fmt.Sprintf("cty.SetValEmpty()")
+		} else {
+			return fmt.Sprintf("cty.SetVal(%#v)", vals)
+		}
+	case val.ty.IsCapsuleType():
+		return fmt.Sprintf("cty.CapsuleVal(%#v, %#v)", val.ty, val.v)
+	}
+
+	// Default exposes implementation details, so should actually cover
+	// all of the cases above for good caller UX.
+	return fmt.Sprintf("cty.Value{ty: %#v, v: %#v}", val.ty, val.v)
+}
+
+// Equals returns True if the receiver and the given other value have the
+// same type and are exactly equal in value.
+//
+// The usual short-circuit rules apply, so the result can be unknown or typed
+// as dynamic if either of the given values are. Use RawEquals to compare
+// if two values are equal *ignoring* the short-circuit rules.
+func (val Value) Equals(other Value) Value {
+	if val.ty.HasDynamicTypes() || other.ty.HasDynamicTypes() {
+		return UnknownVal(Bool)
+	}
+
+	if !val.ty.Equals(other.ty) {
+		return BoolVal(false)
+	}
+
+	if !(val.IsKnown() && other.IsKnown()) {
+		return UnknownVal(Bool)
+	}
+
+	if val.IsNull() || other.IsNull() {
+		if val.IsNull() && other.IsNull() {
+			return BoolVal(true)
+		}
+		return BoolVal(false)
+	}
+
+	ty := val.ty
+	result := false
+
+	switch {
+	case ty == Number:
+		result = val.v.(*big.Float).Cmp(other.v.(*big.Float)) == 0
+	case ty == Bool:
+		result = val.v.(bool) == other.v.(bool)
+	case ty == String:
+		// Simple equality is safe because we NFC-normalize strings as they
+		// enter our world from StringVal, and so we can assume strings are
+		// always in normal form.
+		result = val.v.(string) == other.v.(string)
+	case ty.IsObjectType():
+		oty := ty.typeImpl.(typeObject)
+		result = true
+		for attr, aty := range oty.AttrTypes {
+			lhs := Value{
+				ty: aty,
+				v:  val.v.(map[string]interface{})[attr],
+			}
+			rhs := Value{
+				ty: aty,
+				v:  other.v.(map[string]interface{})[attr],
+			}
+			eq := lhs.Equals(rhs)
+			if !eq.IsKnown() {
+				return UnknownVal(Bool)
+			}
+			if eq.False() {
+				result = false
+				break
+			}
+		}
+	case ty.IsTupleType():
+		tty := ty.typeImpl.(typeTuple)
+		result = true
+		for i, ety := range tty.ElemTypes {
+			lhs := Value{
+				ty: ety,
+				v:  val.v.([]interface{})[i],
+			}
+			rhs := Value{
+				ty: ety,
+				v:  other.v.([]interface{})[i],
+			}
+			eq := lhs.Equals(rhs)
+			if !eq.IsKnown() {
+				return UnknownVal(Bool)
+			}
+			if eq.False() {
+				result = false
+				break
+			}
+		}
+	case ty.IsListType():
+		ety := ty.typeImpl.(typeList).ElementTypeT
+		if len(val.v.([]interface{})) == len(other.v.([]interface{})) {
+			result = true
+			for i := range val.v.([]interface{}) {
+				lhs := Value{
+					ty: ety,
+					v:  val.v.([]interface{})[i],
+				}
+				rhs := Value{
+					ty: ety,
+					v:  other.v.([]interface{})[i],
+				}
+				eq := lhs.Equals(rhs)
+				if !eq.IsKnown() {
+					return UnknownVal(Bool)
+				}
+				if eq.False() {
+					result = false
+					break
+				}
+			}
+		}
+	case ty.IsSetType():
+		s1 := val.v.(set.Set)
+		s2 := other.v.(set.Set)
+		equal := true
+
+		// Note that by our definition of sets it's never possible for two
+		// sets that contain unknown values (directly or indicrectly) to
+		// ever be equal, even if they are otherwise identical.
+
+		// FIXME: iterating both lists and checking each item is not the
+		// ideal implementation here, but it works with the primitives we
+		// have in the set implementation. Perhaps the set implementation
+		// can provide its own equality test later.
+		s1.EachValue(func(v interface{}) {
+			if !s2.Has(v) {
+				equal = false
+			}
+		})
+		s2.EachValue(func(v interface{}) {
+			if !s1.Has(v) {
+				equal = false
+			}
+		})
+
+		result = equal
+	case ty.IsMapType():
+		ety := ty.typeImpl.(typeMap).ElementTypeT
+		if len(val.v.(map[string]interface{})) == len(other.v.(map[string]interface{})) {
+			result = true
+			for k := range val.v.(map[string]interface{}) {
+				if _, ok := other.v.(map[string]interface{})[k]; !ok {
+					result = false
+					break
+				}
+				lhs := Value{
+					ty: ety,
+					v:  val.v.(map[string]interface{})[k],
+				}
+				rhs := Value{
+					ty: ety,
+					v:  other.v.(map[string]interface{})[k],
+				}
+				eq := lhs.Equals(rhs)
+				if !eq.IsKnown() {
+					return UnknownVal(Bool)
+				}
+				if eq.False() {
+					result = false
+					break
+				}
+			}
+		}
+	case ty.IsCapsuleType():
+		// A capsule type's encapsulated value is a pointer to a value of its
+		// native type, so we can just compare these to get the identity test
+		// we need.
+		return BoolVal(val.v == other.v)
+
+	default:
+		// should never happen
+		panic(fmt.Errorf("unsupported value type %#v in Equals", ty))
+	}
+
+	return BoolVal(result)
+}
+
+// NotEqual is a shorthand for Equals followed by Not.
+func (val Value) NotEqual(other Value) Value {
+	return val.Equals(other).Not()
+}
+
+// True returns true if the receiver is True, false if False, and panics if
+// the receiver is not of type Bool.
+//
+// This is a helper function to help write application logic that works with
+// values, rather than a first-class operation. It does not work with unknown
+// or null values. For more robust handling with unknown value
+// short-circuiting, use val.Equals(cty.True).
+func (val Value) True() bool {
+	if val.ty != Bool {
+		panic("not bool")
+	}
+	return val.Equals(True).v.(bool)
+}
+
+// False is the opposite of True.
+func (val Value) False() bool {
+	return !val.True()
+}
+
+// RawEquals returns true if and only if the two given values have the same
+// type and equal value, ignoring the usual short-circuit rules about
+// unknowns and dynamic types.
+//
+// This method is more appropriate for testing than for real use, since it
+// skips over usual semantics around unknowns but as a consequence allows
+// testing the result of another operation that is expected to return unknown.
+// It returns a primitive Go bool rather than a Value to remind us that it
+// is not a first-class value operation.
+func (val Value) RawEquals(other Value) bool {
+	if !val.ty.Equals(other.ty) {
+		return false
+	}
+	if (!val.IsKnown()) && (!other.IsKnown()) {
+		return true
+	}
+	if (val.IsKnown() && !other.IsKnown()) || (other.IsKnown() && !val.IsKnown()) {
+		return false
+	}
+	if val.IsNull() && other.IsNull() {
+		return true
+	}
+	if (val.IsNull() && !other.IsNull()) || (other.IsNull() && !val.IsNull()) {
+		return false
+	}
+	if val.ty == DynamicPseudoType && other.ty == DynamicPseudoType {
+		return true
+	}
+
+	ty := val.ty
+	switch {
+	case ty == Number || ty == Bool || ty == String || ty == DynamicPseudoType:
+		return val.Equals(other).True()
+	case ty.IsObjectType():
+		oty := ty.typeImpl.(typeObject)
+		for attr, aty := range oty.AttrTypes {
+			lhs := Value{
+				ty: aty,
+				v:  val.v.(map[string]interface{})[attr],
+			}
+			rhs := Value{
+				ty: aty,
+				v:  other.v.(map[string]interface{})[attr],
+			}
+			eq := lhs.RawEquals(rhs)
+			if !eq {
+				return false
+			}
+		}
+		return true
+	case ty.IsTupleType():
+		tty := ty.typeImpl.(typeTuple)
+		for i, ety := range tty.ElemTypes {
+			lhs := Value{
+				ty: ety,
+				v:  val.v.([]interface{})[i],
+			}
+			rhs := Value{
+				ty: ety,
+				v:  other.v.([]interface{})[i],
+			}
+			eq := lhs.RawEquals(rhs)
+			if !eq {
+				return false
+			}
+		}
+		return true
+	case ty.IsListType():
+		ety := ty.typeImpl.(typeList).ElementTypeT
+		if len(val.v.([]interface{})) == len(other.v.([]interface{})) {
+			for i := range val.v.([]interface{}) {
+				lhs := Value{
+					ty: ety,
+					v:  val.v.([]interface{})[i],
+				}
+				rhs := Value{
+					ty: ety,
+					v:  other.v.([]interface{})[i],
+				}
+				eq := lhs.RawEquals(rhs)
+				if !eq {
+					return false
+				}
+			}
+			return true
+		}
+		return false
+	case ty.IsSetType():
+		s1 := val.v.(set.Set)
+		s2 := other.v.(set.Set)
+
+		// Since we're intentionally ignoring our rule that two unknowns
+		// are never equal, we can cheat here.
+		// (This isn't 100% right since e.g. it will fail if the set contains
+		// numbers that are infinite, which DeepEqual can't compare properly.
+		// We're accepting that limitation for simplicity here, since this
+		// function is here primarily for testing.)
+		return reflect.DeepEqual(s1, s2)
+
+	case ty.IsMapType():
+		ety := ty.typeImpl.(typeMap).ElementTypeT
+		if len(val.v.(map[string]interface{})) == len(other.v.(map[string]interface{})) {
+			for k := range val.v.(map[string]interface{}) {
+				if _, ok := other.v.(map[string]interface{})[k]; !ok {
+					return false
+				}
+				lhs := Value{
+					ty: ety,
+					v:  val.v.(map[string]interface{})[k],
+				}
+				rhs := Value{
+					ty: ety,
+					v:  other.v.(map[string]interface{})[k],
+				}
+				eq := lhs.RawEquals(rhs)
+				if !eq {
+					return false
+				}
+			}
+			return true
+		}
+		return false
+	case ty.IsCapsuleType():
+		// A capsule type's encapsulated value is a pointer to a value of its
+		// native type, so we can just compare these to get the identity test
+		// we need.
+		return val.v == other.v
+
+	default:
+		// should never happen
+		panic(fmt.Errorf("unsupported value type %#v in RawEquals", ty))
+	}
+}
+
+// Add returns the sum of the receiver and the given other value. Both values
+// must be numbers; this method will panic if not.
+func (val Value) Add(other Value) Value {
+	if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Number)
+		return *shortCircuit
+	}
+
+	ret := new(big.Float)
+	ret.Add(val.v.(*big.Float), other.v.(*big.Float))
+	return NumberVal(ret)
+}
+
+// Subtract returns receiver minus the given other value. Both values must be
+// numbers; this method will panic if not.
+func (val Value) Subtract(other Value) Value {
+	if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Number)
+		return *shortCircuit
+	}
+
+	return val.Add(other.Negate())
+}
+
+// Negate returns the numeric negative of the receiver, which must be a number.
+// This method will panic when given a value of any other type.
+func (val Value) Negate() Value {
+	if shortCircuit := mustTypeCheck(Number, Number, val); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Number)
+		return *shortCircuit
+	}
+
+	ret := new(big.Float).Neg(val.v.(*big.Float))
+	return NumberVal(ret)
+}
+
+// Multiply returns the product of the receiver and the given other value.
+// Both values must be numbers; this method will panic if not.
+func (val Value) Multiply(other Value) Value {
+	if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Number)
+		return *shortCircuit
+	}
+
+	ret := new(big.Float)
+	ret.Mul(val.v.(*big.Float), other.v.(*big.Float))
+	return NumberVal(ret)
+}
+
+// Divide returns the quotient of the receiver and the given other value.
+// Both values must be numbers; this method will panic if not.
+//
+// If the "other" value is exactly zero, this operation will return either
+// PositiveInfinity or NegativeInfinity, depending on the sign of the
+// receiver value. For some use-cases the presence of infinities may be
+// undesirable, in which case the caller should check whether the
+// other value equals zero before calling and raise an error instead.
+//
+// If both values are zero or infinity, this function will panic with
+// an instance of big.ErrNaN.
+func (val Value) Divide(other Value) Value {
+	if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Number)
+		return *shortCircuit
+	}
+
+	ret := new(big.Float)
+	ret.Quo(val.v.(*big.Float), other.v.(*big.Float))
+	return NumberVal(ret)
+}
+
+// Modulo returns the remainder of an integer division of the receiver and
+// the given other value. Both values must be numbers; this method will panic
+// if not.
+//
+// If the "other" value is exactly zero, this operation will return either
+// PositiveInfinity or NegativeInfinity, depending on the sign of the
+// receiver value. For some use-cases the presence of infinities may be
+// undesirable, in which case the caller should check whether the
+// other value equals zero before calling and raise an error instead.
+//
+// This operation is primarily here for use with nonzero natural numbers.
+// Modulo with "other" as a non-natural number gets somewhat philosophical,
+// and this function takes a position on what that should mean, but callers
+// may wish to disallow such things outright or implement their own modulo
+// if they disagree with the interpretation used here.
+func (val Value) Modulo(other Value) Value {
+	if shortCircuit := mustTypeCheck(Number, Number, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Number)
+		return *shortCircuit
+	}
+
+	// We cheat a bit here with infinities, just abusing the Multiply operation
+	// to get an infinite result of the correct sign.
+	if val == PositiveInfinity || val == NegativeInfinity || other == PositiveInfinity || other == NegativeInfinity {
+		return val.Multiply(other)
+	}
+
+	if other.RawEquals(Zero) {
+		return val
+	}
+
+	// FIXME: This is a bit clumsy. Should come back later and see if there's a
+	// more straightforward way to do this.
+	rat := val.Divide(other)
+	ratFloorInt := &big.Int{}
+	rat.v.(*big.Float).Int(ratFloorInt)
+	work := (&big.Float{}).SetInt(ratFloorInt)
+	work.Mul(other.v.(*big.Float), work)
+	work.Sub(val.v.(*big.Float), work)
+
+	return NumberVal(work)
+}
+
+// Absolute returns the absolute (signless) value of the receiver, which must
+// be a number or this method will panic.
+func (val Value) Absolute() Value {
+	if shortCircuit := mustTypeCheck(Number, Number, val); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Number)
+		return *shortCircuit
+	}
+
+	ret := (&big.Float{}).Abs(val.v.(*big.Float))
+	return NumberVal(ret)
+}
+
+// GetAttr returns the value of the given attribute of the receiver, which
+// must be of an object type that has an attribute of the given name.
+// This method will panic if the receiver type is not compatible.
+//
+// The method will also panic if the given attribute name is not defined
+// for the value's type. Use the attribute-related methods on Type to
+// check for the validity of an attribute before trying to use it.
+//
+// This method may be called on a value whose type is DynamicPseudoType,
+// in which case the result will also be DynamicVal.
+func (val Value) GetAttr(name string) Value {
+	if val.ty == DynamicPseudoType {
+		return DynamicVal
+	}
+
+	if !val.ty.IsObjectType() {
+		panic("value is not an object")
+	}
+	if !val.ty.HasAttribute(name) {
+		panic("value has no attribute of that name")
+	}
+
+	attrType := val.ty.AttributeType(name)
+
+	if !val.IsKnown() {
+		return UnknownVal(attrType)
+	}
+
+	return Value{
+		ty: attrType,
+		v:  val.v.(map[string]interface{})[name],
+	}
+}
+
+// Index returns the value of an element of the receiver, which must have
+// either a list, map or tuple type. This method will panic if the receiver
+// type is not compatible.
+//
+// The key value must be the correct type for the receving collection: a
+// number if the collection is a list or tuple, or a string if it is a map.
+// In the case of a list or tuple, the given number must be convertable to int
+// or this method will panic. The key may alternatively be of
+// DynamicPseudoType, in which case the result itself is an unknown of the
+// collection's element type.
+//
+// The result is of the receiver collection's element type, or in the case
+// of a tuple the type of the specific element index requested.
+//
+// This method may be called on a value whose type is DynamicPseudoType,
+// in which case the result will also be the DynamicValue.
+func (val Value) Index(key Value) Value {
+	if val.ty == DynamicPseudoType {
+		return DynamicVal
+	}
+
+	switch {
+	case val.Type().IsListType():
+		elty := val.Type().ElementType()
+		if key.Type() == DynamicPseudoType {
+			return UnknownVal(elty)
+		}
+
+		if key.Type() != Number {
+			panic("element key for list must be number")
+		}
+		if !key.IsKnown() {
+			return UnknownVal(elty)
+		}
+
+		if !val.IsKnown() {
+			return UnknownVal(elty)
+		}
+
+		index, accuracy := key.v.(*big.Float).Int64()
+		if accuracy != big.Exact || index < 0 {
+			panic("element key for list must be non-negative integer")
+		}
+
+		return Value{
+			ty: elty,
+			v:  val.v.([]interface{})[index],
+		}
+	case val.Type().IsMapType():
+		elty := val.Type().ElementType()
+		if key.Type() == DynamicPseudoType {
+			return UnknownVal(elty)
+		}
+
+		if key.Type() != String {
+			panic("element key for map must be string")
+		}
+		if !key.IsKnown() {
+			return UnknownVal(elty)
+		}
+
+		if !val.IsKnown() {
+			return UnknownVal(elty)
+		}
+
+		keyStr := key.v.(string)
+
+		return Value{
+			ty: elty,
+			v:  val.v.(map[string]interface{})[keyStr],
+		}
+	case val.Type().IsTupleType():
+		if key.Type() == DynamicPseudoType {
+			return DynamicVal
+		}
+
+		if key.Type() != Number {
+			panic("element key for tuple must be number")
+		}
+		if !key.IsKnown() {
+			return DynamicVal
+		}
+
+		index, accuracy := key.v.(*big.Float).Int64()
+		if accuracy != big.Exact || index < 0 {
+			panic("element key for list must be non-negative integer")
+		}
+
+		eltys := val.Type().TupleElementTypes()
+
+		if !val.IsKnown() {
+			return UnknownVal(eltys[index])
+		}
+
+		return Value{
+			ty: eltys[index],
+			v:  val.v.([]interface{})[index],
+		}
+	default:
+		panic("not a list, map, or tuple type")
+	}
+}
+
+// HasIndex returns True if the receiver (which must be supported for Index)
+// has an element with the given index key, or False if it does not.
+//
+// The result will be UnknownVal(Bool) if either the collection or the
+// key value are unknown.
+//
+// This method will panic if the receiver is not indexable, but does not
+// impose any panic-causing type constraints on the key.
+func (val Value) HasIndex(key Value) Value {
+	if val.ty == DynamicPseudoType {
+		return UnknownVal(Bool)
+	}
+
+	switch {
+	case val.Type().IsListType():
+		if key.Type() == DynamicPseudoType {
+			return UnknownVal(Bool)
+		}
+
+		if key.Type() != Number {
+			return False
+		}
+		if !key.IsKnown() {
+			return UnknownVal(Bool)
+		}
+		if !val.IsKnown() {
+			return UnknownVal(Bool)
+		}
+
+		index, accuracy := key.v.(*big.Float).Int64()
+		if accuracy != big.Exact || index < 0 {
+			return False
+		}
+
+		return BoolVal(int(index) < len(val.v.([]interface{})) && index >= 0)
+	case val.Type().IsMapType():
+		if key.Type() == DynamicPseudoType {
+			return UnknownVal(Bool)
+		}
+
+		if key.Type() != String {
+			return False
+		}
+		if !key.IsKnown() {
+			return UnknownVal(Bool)
+		}
+		if !val.IsKnown() {
+			return UnknownVal(Bool)
+		}
+
+		keyStr := key.v.(string)
+		_, exists := val.v.(map[string]interface{})[keyStr]
+
+		return BoolVal(exists)
+	case val.Type().IsTupleType():
+		if key.Type() == DynamicPseudoType {
+			return UnknownVal(Bool)
+		}
+
+		if key.Type() != Number {
+			return False
+		}
+		if !key.IsKnown() {
+			return UnknownVal(Bool)
+		}
+
+		index, accuracy := key.v.(*big.Float).Int64()
+		if accuracy != big.Exact || index < 0 {
+			return False
+		}
+
+		length := val.Type().Length()
+		return BoolVal(int(index) < length && index >= 0)
+	default:
+		panic("not a list, map, or tuple type")
+	}
+}
+
+// Length returns the length of the receiver, which must be a collection type
+// or tuple type, as a number value. If the receiver is not a compatible type
+// then this method will panic.
+//
+// If the receiver is unknown then the result is also unknown.
+//
+// If the receiver is null then this function will panic.
+//
+// Note that Length is not supported for strings. To determine the length
+// of a string, call AsString and take the length of the native Go string
+// that is returned.
+func (val Value) Length() Value {
+	if val.Type().IsTupleType() {
+		// For tuples, we can return the length even if the value is not known.
+		return NumberIntVal(int64(val.Type().Length()))
+	}
+
+	if !val.IsKnown() {
+		return UnknownVal(Number)
+	}
+
+	return NumberIntVal(int64(val.LengthInt()))
+}
+
+// LengthInt is like Length except it returns an int. It has the same behavior
+// as Length except that it will panic if the receiver is unknown.
+//
+// This is an integration method provided for the convenience of code bridging
+// into Go's type system.
+func (val Value) LengthInt() int {
+	if val.Type().IsTupleType() {
+		// For tuples, we can return the length even if the value is not known.
+		return val.Type().Length()
+	}
+	if !val.IsKnown() {
+		panic("value is not known")
+	}
+	if val.IsNull() {
+		panic("value is null")
+	}
+
+	switch {
+
+	case val.ty.IsListType():
+		return len(val.v.([]interface{}))
+
+	case val.ty.IsSetType():
+		return val.v.(set.Set).Length()
+
+	case val.ty.IsMapType():
+		return len(val.v.(map[string]interface{}))
+
+	default:
+		panic("value is not a collection")
+	}
+}
+
+// ElementIterator returns an ElementIterator for iterating the elements
+// of the receiver, which must be a collection type, a tuple type, or an object
+// type. If called on a method of any other type, this method will panic.
+//
+// The value must be Known and non-Null, or this method will panic.
+//
+// If the receiver is of a list type, the returned keys will be of type Number
+// and the values will be of the list's element type.
+//
+// If the receiver is of a map type, the returned keys will be of type String
+// and the value will be of the map's element type. Elements are passed in
+// ascending lexicographical order by key.
+//
+// If the receiver is of a set type, each element is returned as both the
+// key and the value, since set members are their own identity.
+//
+// If the receiver is of a tuple type, the returned keys will be of type Number
+// and the value will be of the corresponding element's type.
+//
+// If the receiver is of an object type, the returned keys will be of type
+// String and the value will be of the corresponding attributes's type.
+//
+// ElementIterator is an integration method, so it cannot handle Unknown
+// values. This method will panic if the receiver is Unknown.
+func (val Value) ElementIterator() ElementIterator {
+	if !val.IsKnown() {
+		panic("can't use ElementIterator on unknown value")
+	}
+	if val.IsNull() {
+		panic("can't use ElementIterator on null value")
+	}
+	return elementIterator(val)
+}
+
+// CanIterateElements returns true if the receiver can support the
+// ElementIterator method (and by extension, ForEachElement) without panic.
+func (val Value) CanIterateElements() bool {
+	return canElementIterator(val)
+}
+
+// ForEachElement executes a given callback function for each element of
+// the receiver, which must be a collection type or tuple type, or this method
+// will panic.
+//
+// ForEachElement uses ElementIterator internally, and so the values passed
+// to the callback are as described for ElementIterator.
+//
+// Returns true if the iteration exited early due to the callback function
+// returning true, or false if the loop ran to completion.
+//
+// ForEachElement is an integration method, so it cannot handle Unknown
+// values. This method will panic if the receiver is Unknown.
+func (val Value) ForEachElement(cb ElementCallback) bool {
+	it := val.ElementIterator()
+	for it.Next() {
+		key, val := it.Element()
+		stop := cb(key, val)
+		if stop {
+			return true
+		}
+	}
+	return false
+}
+
+// Not returns the logical inverse of the receiver, which must be of type
+// Bool or this method will panic.
+func (val Value) Not() Value {
+	if shortCircuit := mustTypeCheck(Bool, Bool, val); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Bool)
+		return *shortCircuit
+	}
+
+	return BoolVal(!val.v.(bool))
+}
+
+// And returns the result of logical AND with the receiver and the other given
+// value, which must both be of type Bool or this method will panic.
+func (val Value) And(other Value) Value {
+	if shortCircuit := mustTypeCheck(Bool, Bool, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Bool)
+		return *shortCircuit
+	}
+
+	return BoolVal(val.v.(bool) && other.v.(bool))
+}
+
+// Or returns the result of logical OR with the receiver and the other given
+// value, which must both be of type Bool or this method will panic.
+func (val Value) Or(other Value) Value {
+	if shortCircuit := mustTypeCheck(Bool, Bool, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Bool)
+		return *shortCircuit
+	}
+
+	return BoolVal(val.v.(bool) || other.v.(bool))
+}
+
+// LessThan returns True if the receiver is less than the other given value,
+// which must both be numbers or this method will panic.
+func (val Value) LessThan(other Value) Value {
+	if shortCircuit := mustTypeCheck(Number, Bool, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Bool)
+		return *shortCircuit
+	}
+
+	return BoolVal(val.v.(*big.Float).Cmp(other.v.(*big.Float)) < 0)
+}
+
+// GreaterThan returns True if the receiver is greater than the other given
+// value, which must both be numbers or this method will panic.
+func (val Value) GreaterThan(other Value) Value {
+	if shortCircuit := mustTypeCheck(Number, Bool, val, other); shortCircuit != nil {
+		shortCircuit = forceShortCircuitType(shortCircuit, Bool)
+		return *shortCircuit
+	}
+
+	return BoolVal(val.v.(*big.Float).Cmp(other.v.(*big.Float)) > 0)
+}
+
+// LessThanOrEqualTo is equivalent to LessThan and Equal combined with Or.
+func (val Value) LessThanOrEqualTo(other Value) Value {
+	return val.LessThan(other).Or(val.Equals(other))
+}
+
+// GreaterThanOrEqualTo is equivalent to GreaterThan and Equal combined with Or.
+func (val Value) GreaterThanOrEqualTo(other Value) Value {
+	return val.GreaterThan(other).Or(val.Equals(other))
+}
+
+// AsString returns the native string from a non-null, non-unknown cty.String
+// value, or panics if called on any other value.
+func (val Value) AsString() string {
+	if val.ty != String {
+		panic("not a string")
+	}
+	if val.IsNull() {
+		panic("value is null")
+	}
+	if !val.IsKnown() {
+		panic("value is unknown")
+	}
+
+	return val.v.(string)
+}
+
+// AsBigFloat returns a big.Float representation of a non-null, non-unknown
+// cty.Number value, or panics if called on any other value.
+//
+// For more convenient conversions to other native numeric types, use the
+// "convert" package.
+func (val Value) AsBigFloat() *big.Float {
+	if val.ty != Number {
+		panic("not a number")
+	}
+	if val.IsNull() {
+		panic("value is null")
+	}
+	if !val.IsKnown() {
+		panic("value is unknown")
+	}
+
+	// Copy the float so that callers can't mutate our internal state
+	ret := *(val.v.(*big.Float))
+
+	return &ret
+}
+
+// EncapsulatedValue returns the native value encapsulated in a non-null,
+// non-unknown capsule-typed value, or panics if called on any other value.
+//
+// The result is the same pointer that was passed to CapsuleVal to create
+// the value. Since cty considers values to be immutable, it is strongly
+// recommended to treat the encapsulated value itself as immutable too.
+func (val Value) EncapsulatedValue() interface{} {
+	if !val.Type().IsCapsuleType() {
+		panic("not a capsule-typed value")
+	}
+
+	return val.v
+}
diff --git a/vendor/golang.org/x/text/LICENSE b/vendor/golang.org/x/text/LICENSE
new file mode 100644
index 000000000..6a66aea5e
--- /dev/null
+++ b/vendor/golang.org/x/text/LICENSE
@@ -0,0 +1,27 @@
+Copyright (c) 2009 The Go Authors. All rights reserved.
+
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+
+   * Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+   * Redistributions in binary form must reproduce the above
+copyright notice, this list of conditions and the following disclaimer
+in the documentation and/or other materials provided with the
+distribution.
+   * Neither the name of Google Inc. nor the names of its
+contributors may be used to endorse or promote products derived from
+this software without specific prior written permission.
+
+THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
diff --git a/vendor/golang.org/x/text/PATENTS b/vendor/golang.org/x/text/PATENTS
new file mode 100644
index 000000000..733099041
--- /dev/null
+++ b/vendor/golang.org/x/text/PATENTS
@@ -0,0 +1,22 @@
+Additional IP Rights Grant (Patents)
+
+"This implementation" means the copyrightable works distributed by
+Google as part of the Go project.
+
+Google hereby grants to You a perpetual, worldwide, non-exclusive,
+no-charge, royalty-free, irrevocable (except as stated in this section)
+patent license to make, have made, use, offer to sell, sell, import,
+transfer and otherwise run, modify and propagate the contents of this
+implementation of Go, where such license applies only to those patent
+claims, both currently owned or controlled by Google and acquired in
+the future, licensable by Google that are necessarily infringed by this
+implementation of Go.  This grant does not include claims that would be
+infringed only as a consequence of further modification of this
+implementation.  If you or your agent or exclusive licensee institute or
+order or agree to the institution of patent litigation against any
+entity (including a cross-claim or counterclaim in a lawsuit) alleging
+that this implementation of Go or any code incorporated within this
+implementation of Go constitutes direct or contributory patent
+infringement, or inducement of patent infringement, then any patent
+rights granted to you under this License for this implementation of Go
+shall terminate as of the date such litigation is filed.
diff --git a/vendor/golang.org/x/text/transform/transform.go b/vendor/golang.org/x/text/transform/transform.go
new file mode 100644
index 000000000..fe47b9b35
--- /dev/null
+++ b/vendor/golang.org/x/text/transform/transform.go
@@ -0,0 +1,705 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package transform provides reader and writer wrappers that transform the
+// bytes passing through as well as various transformations. Example
+// transformations provided by other packages include normalization and
+// conversion between character sets.
+package transform // import "golang.org/x/text/transform"
+
+import (
+	"bytes"
+	"errors"
+	"io"
+	"unicode/utf8"
+)
+
+var (
+	// ErrShortDst means that the destination buffer was too short to
+	// receive all of the transformed bytes.
+	ErrShortDst = errors.New("transform: short destination buffer")
+
+	// ErrShortSrc means that the source buffer has insufficient data to
+	// complete the transformation.
+	ErrShortSrc = errors.New("transform: short source buffer")
+
+	// ErrEndOfSpan means that the input and output (the transformed input)
+	// are not identical.
+	ErrEndOfSpan = errors.New("transform: input and output are not identical")
+
+	// errInconsistentByteCount means that Transform returned success (nil
+	// error) but also returned nSrc inconsistent with the src argument.
+	errInconsistentByteCount = errors.New("transform: inconsistent byte count returned")
+
+	// errShortInternal means that an internal buffer is not large enough
+	// to make progress and the Transform operation must be aborted.
+	errShortInternal = errors.New("transform: short internal buffer")
+)
+
+// Transformer transforms bytes.
+type Transformer interface {
+	// Transform writes to dst the transformed bytes read from src, and
+	// returns the number of dst bytes written and src bytes read. The
+	// atEOF argument tells whether src represents the last bytes of the
+	// input.
+	//
+	// Callers should always process the nDst bytes produced and account
+	// for the nSrc bytes consumed before considering the error err.
+	//
+	// A nil error means that all of the transformed bytes (whether freshly
+	// transformed from src or left over from previous Transform calls)
+	// were written to dst. A nil error can be returned regardless of
+	// whether atEOF is true. If err is nil then nSrc must equal len(src);
+	// the converse is not necessarily true.
+	//
+	// ErrShortDst means that dst was too short to receive all of the
+	// transformed bytes. ErrShortSrc means that src had insufficient data
+	// to complete the transformation. If both conditions apply, then
+	// either error may be returned. Other than the error conditions listed
+	// here, implementations are free to report other errors that arise.
+	Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error)
+
+	// Reset resets the state and allows a Transformer to be reused.
+	Reset()
+}
+
+// SpanningTransformer extends the Transformer interface with a Span method
+// that determines how much of the input already conforms to the Transformer.
+type SpanningTransformer interface {
+	Transformer
+
+	// Span returns a position in src such that transforming src[:n] results in
+	// identical output src[:n] for these bytes. It does not necessarily return
+	// the largest such n. The atEOF argument tells whether src represents the
+	// last bytes of the input.
+	//
+	// Callers should always account for the n bytes consumed before
+	// considering the error err.
+	//
+	// A nil error means that all input bytes are known to be identical to the
+	// output produced by the Transformer. A nil error can be be returned
+	// regardless of whether atEOF is true. If err is nil, then then n must
+	// equal len(src); the converse is not necessarily true.
+	//
+	// ErrEndOfSpan means that the Transformer output may differ from the
+	// input after n bytes. Note that n may be len(src), meaning that the output
+	// would contain additional bytes after otherwise identical output.
+	// ErrShortSrc means that src had insufficient data to determine whether the
+	// remaining bytes would change. Other than the error conditions listed
+	// here, implementations are free to report other errors that arise.
+	//
+	// Calling Span can modify the Transformer state as a side effect. In
+	// effect, it does the transformation just as calling Transform would, only
+	// without copying to a destination buffer and only up to a point it can
+	// determine the input and output bytes are the same. This is obviously more
+	// limited than calling Transform, but can be more efficient in terms of
+	// copying and allocating buffers. Calls to Span and Transform may be
+	// interleaved.
+	Span(src []byte, atEOF bool) (n int, err error)
+}
+
+// NopResetter can be embedded by implementations of Transformer to add a nop
+// Reset method.
+type NopResetter struct{}
+
+// Reset implements the Reset method of the Transformer interface.
+func (NopResetter) Reset() {}
+
+// Reader wraps another io.Reader by transforming the bytes read.
+type Reader struct {
+	r   io.Reader
+	t   Transformer
+	err error
+
+	// dst[dst0:dst1] contains bytes that have been transformed by t but
+	// not yet copied out via Read.
+	dst        []byte
+	dst0, dst1 int
+
+	// src[src0:src1] contains bytes that have been read from r but not
+	// yet transformed through t.
+	src        []byte
+	src0, src1 int
+
+	// transformComplete is whether the transformation is complete,
+	// regardless of whether or not it was successful.
+	transformComplete bool
+}
+
+const defaultBufSize = 4096
+
+// NewReader returns a new Reader that wraps r by transforming the bytes read
+// via t. It calls Reset on t.
+func NewReader(r io.Reader, t Transformer) *Reader {
+	t.Reset()
+	return &Reader{
+		r:   r,
+		t:   t,
+		dst: make([]byte, defaultBufSize),
+		src: make([]byte, defaultBufSize),
+	}
+}
+
+// Read implements the io.Reader interface.
+func (r *Reader) Read(p []byte) (int, error) {
+	n, err := 0, error(nil)
+	for {
+		// Copy out any transformed bytes and return the final error if we are done.
+		if r.dst0 != r.dst1 {
+			n = copy(p, r.dst[r.dst0:r.dst1])
+			r.dst0 += n
+			if r.dst0 == r.dst1 && r.transformComplete {
+				return n, r.err
+			}
+			return n, nil
+		} else if r.transformComplete {
+			return 0, r.err
+		}
+
+		// Try to transform some source bytes, or to flush the transformer if we
+		// are out of source bytes. We do this even if r.r.Read returned an error.
+		// As the io.Reader documentation says, "process the n > 0 bytes returned
+		// before considering the error".
+		if r.src0 != r.src1 || r.err != nil {
+			r.dst0 = 0
+			r.dst1, n, err = r.t.Transform(r.dst, r.src[r.src0:r.src1], r.err == io.EOF)
+			r.src0 += n
+
+			switch {
+			case err == nil:
+				if r.src0 != r.src1 {
+					r.err = errInconsistentByteCount
+				}
+				// The Transform call was successful; we are complete if we
+				// cannot read more bytes into src.
+				r.transformComplete = r.err != nil
+				continue
+			case err == ErrShortDst && (r.dst1 != 0 || n != 0):
+				// Make room in dst by copying out, and try again.
+				continue
+			case err == ErrShortSrc && r.src1-r.src0 != len(r.src) && r.err == nil:
+				// Read more bytes into src via the code below, and try again.
+			default:
+				r.transformComplete = true
+				// The reader error (r.err) takes precedence over the
+				// transformer error (err) unless r.err is nil or io.EOF.
+				if r.err == nil || r.err == io.EOF {
+					r.err = err
+				}
+				continue
+			}
+		}
+
+		// Move any untransformed source bytes to the start of the buffer
+		// and read more bytes.
+		if r.src0 != 0 {
+			r.src0, r.src1 = 0, copy(r.src, r.src[r.src0:r.src1])
+		}
+		n, r.err = r.r.Read(r.src[r.src1:])
+		r.src1 += n
+	}
+}
+
+// TODO: implement ReadByte (and ReadRune??).
+
+// Writer wraps another io.Writer by transforming the bytes read.
+// The user needs to call Close to flush unwritten bytes that may
+// be buffered.
+type Writer struct {
+	w   io.Writer
+	t   Transformer
+	dst []byte
+
+	// src[:n] contains bytes that have not yet passed through t.
+	src []byte
+	n   int
+}
+
+// NewWriter returns a new Writer that wraps w by transforming the bytes written
+// via t. It calls Reset on t.
+func NewWriter(w io.Writer, t Transformer) *Writer {
+	t.Reset()
+	return &Writer{
+		w:   w,
+		t:   t,
+		dst: make([]byte, defaultBufSize),
+		src: make([]byte, defaultBufSize),
+	}
+}
+
+// Write implements the io.Writer interface. If there are not enough
+// bytes available to complete a Transform, the bytes will be buffered
+// for the next write. Call Close to convert the remaining bytes.
+func (w *Writer) Write(data []byte) (n int, err error) {
+	src := data
+	if w.n > 0 {
+		// Append bytes from data to the last remainder.
+		// TODO: limit the amount copied on first try.
+		n = copy(w.src[w.n:], data)
+		w.n += n
+		src = w.src[:w.n]
+	}
+	for {
+		nDst, nSrc, err := w.t.Transform(w.dst, src, false)
+		if _, werr := w.w.Write(w.dst[:nDst]); werr != nil {
+			return n, werr
+		}
+		src = src[nSrc:]
+		if w.n == 0 {
+			n += nSrc
+		} else if len(src) <= n {
+			// Enough bytes from w.src have been consumed. We make src point
+			// to data instead to reduce the copying.
+			w.n = 0
+			n -= len(src)
+			src = data[n:]
+			if n < len(data) && (err == nil || err == ErrShortSrc) {
+				continue
+			}
+		}
+		switch err {
+		case ErrShortDst:
+			// This error is okay as long as we are making progress.
+			if nDst > 0 || nSrc > 0 {
+				continue
+			}
+		case ErrShortSrc:
+			if len(src) < len(w.src) {
+				m := copy(w.src, src)
+				// If w.n > 0, bytes from data were already copied to w.src and n
+				// was already set to the number of bytes consumed.
+				if w.n == 0 {
+					n += m
+				}
+				w.n = m
+				err = nil
+			} else if nDst > 0 || nSrc > 0 {
+				// Not enough buffer to store the remainder. Keep processing as
+				// long as there is progress. Without this case, transforms that
+				// require a lookahead larger than the buffer may result in an
+				// error. This is not something one may expect to be common in
+				// practice, but it may occur when buffers are set to small
+				// sizes during testing.
+				continue
+			}
+		case nil:
+			if w.n > 0 {
+				err = errInconsistentByteCount
+			}
+		}
+		return n, err
+	}
+}
+
+// Close implements the io.Closer interface.
+func (w *Writer) Close() error {
+	src := w.src[:w.n]
+	for {
+		nDst, nSrc, err := w.t.Transform(w.dst, src, true)
+		if _, werr := w.w.Write(w.dst[:nDst]); werr != nil {
+			return werr
+		}
+		if err != ErrShortDst {
+			return err
+		}
+		src = src[nSrc:]
+	}
+}
+
+type nop struct{ NopResetter }
+
+func (nop) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	n := copy(dst, src)
+	if n < len(src) {
+		err = ErrShortDst
+	}
+	return n, n, err
+}
+
+func (nop) Span(src []byte, atEOF bool) (n int, err error) {
+	return len(src), nil
+}
+
+type discard struct{ NopResetter }
+
+func (discard) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	return 0, len(src), nil
+}
+
+var (
+	// Discard is a Transformer for which all Transform calls succeed
+	// by consuming all bytes and writing nothing.
+	Discard Transformer = discard{}
+
+	// Nop is a SpanningTransformer that copies src to dst.
+	Nop SpanningTransformer = nop{}
+)
+
+// chain is a sequence of links. A chain with N Transformers has N+1 links and
+// N+1 buffers. Of those N+1 buffers, the first and last are the src and dst
+// buffers given to chain.Transform and the middle N-1 buffers are intermediate
+// buffers owned by the chain. The i'th link transforms bytes from the i'th
+// buffer chain.link[i].b at read offset chain.link[i].p to the i+1'th buffer
+// chain.link[i+1].b at write offset chain.link[i+1].n, for i in [0, N).
+type chain struct {
+	link []link
+	err  error
+	// errStart is the index at which the error occurred plus 1. Processing
+	// errStart at this level at the next call to Transform. As long as
+	// errStart > 0, chain will not consume any more source bytes.
+	errStart int
+}
+
+func (c *chain) fatalError(errIndex int, err error) {
+	if i := errIndex + 1; i > c.errStart {
+		c.errStart = i
+		c.err = err
+	}
+}
+
+type link struct {
+	t Transformer
+	// b[p:n] holds the bytes to be transformed by t.
+	b []byte
+	p int
+	n int
+}
+
+func (l *link) src() []byte {
+	return l.b[l.p:l.n]
+}
+
+func (l *link) dst() []byte {
+	return l.b[l.n:]
+}
+
+// Chain returns a Transformer that applies t in sequence.
+func Chain(t ...Transformer) Transformer {
+	if len(t) == 0 {
+		return nop{}
+	}
+	c := &chain{link: make([]link, len(t)+1)}
+	for i, tt := range t {
+		c.link[i].t = tt
+	}
+	// Allocate intermediate buffers.
+	b := make([][defaultBufSize]byte, len(t)-1)
+	for i := range b {
+		c.link[i+1].b = b[i][:]
+	}
+	return c
+}
+
+// Reset resets the state of Chain. It calls Reset on all the Transformers.
+func (c *chain) Reset() {
+	for i, l := range c.link {
+		if l.t != nil {
+			l.t.Reset()
+		}
+		c.link[i].p, c.link[i].n = 0, 0
+	}
+}
+
+// TODO: make chain use Span (is going to be fun to implement!)
+
+// Transform applies the transformers of c in sequence.
+func (c *chain) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	// Set up src and dst in the chain.
+	srcL := &c.link[0]
+	dstL := &c.link[len(c.link)-1]
+	srcL.b, srcL.p, srcL.n = src, 0, len(src)
+	dstL.b, dstL.n = dst, 0
+	var lastFull, needProgress bool // for detecting progress
+
+	// i is the index of the next Transformer to apply, for i in [low, high].
+	// low is the lowest index for which c.link[low] may still produce bytes.
+	// high is the highest index for which c.link[high] has a Transformer.
+	// The error returned by Transform determines whether to increase or
+	// decrease i. We try to completely fill a buffer before converting it.
+	for low, i, high := c.errStart, c.errStart, len(c.link)-2; low <= i && i <= high; {
+		in, out := &c.link[i], &c.link[i+1]
+		nDst, nSrc, err0 := in.t.Transform(out.dst(), in.src(), atEOF && low == i)
+		out.n += nDst
+		in.p += nSrc
+		if i > 0 && in.p == in.n {
+			in.p, in.n = 0, 0
+		}
+		needProgress, lastFull = lastFull, false
+		switch err0 {
+		case ErrShortDst:
+			// Process the destination buffer next. Return if we are already
+			// at the high index.
+			if i == high {
+				return dstL.n, srcL.p, ErrShortDst
+			}
+			if out.n != 0 {
+				i++
+				// If the Transformer at the next index is not able to process any
+				// source bytes there is nothing that can be done to make progress
+				// and the bytes will remain unprocessed. lastFull is used to
+				// detect this and break out of the loop with a fatal error.
+				lastFull = true
+				continue
+			}
+			// The destination buffer was too small, but is completely empty.
+			// Return a fatal error as this transformation can never complete.
+			c.fatalError(i, errShortInternal)
+		case ErrShortSrc:
+			if i == 0 {
+				// Save ErrShortSrc in err. All other errors take precedence.
+				err = ErrShortSrc
+				break
+			}
+			// Source bytes were depleted before filling up the destination buffer.
+			// Verify we made some progress, move the remaining bytes to the errStart
+			// and try to get more source bytes.
+			if needProgress && nSrc == 0 || in.n-in.p == len(in.b) {
+				// There were not enough source bytes to proceed while the source
+				// buffer cannot hold any more bytes. Return a fatal error as this
+				// transformation can never complete.
+				c.fatalError(i, errShortInternal)
+				break
+			}
+			// in.b is an internal buffer and we can make progress.
+			in.p, in.n = 0, copy(in.b, in.src())
+			fallthrough
+		case nil:
+			// if i == low, we have depleted the bytes at index i or any lower levels.
+			// In that case we increase low and i. In all other cases we decrease i to
+			// fetch more bytes before proceeding to the next index.
+			if i > low {
+				i--
+				continue
+			}
+		default:
+			c.fatalError(i, err0)
+		}
+		// Exhausted level low or fatal error: increase low and continue
+		// to process the bytes accepted so far.
+		i++
+		low = i
+	}
+
+	// If c.errStart > 0, this means we found a fatal error.  We will clear
+	// all upstream buffers. At this point, no more progress can be made
+	// downstream, as Transform would have bailed while handling ErrShortDst.
+	if c.errStart > 0 {
+		for i := 1; i < c.errStart; i++ {
+			c.link[i].p, c.link[i].n = 0, 0
+		}
+		err, c.errStart, c.err = c.err, 0, nil
+	}
+	return dstL.n, srcL.p, err
+}
+
+// Deprecated: use runes.Remove instead.
+func RemoveFunc(f func(r rune) bool) Transformer {
+	return removeF(f)
+}
+
+type removeF func(r rune) bool
+
+func (removeF) Reset() {}
+
+// Transform implements the Transformer interface.
+func (t removeF) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	for r, sz := rune(0), 0; len(src) > 0; src = src[sz:] {
+
+		if r = rune(src[0]); r < utf8.RuneSelf {
+			sz = 1
+		} else {
+			r, sz = utf8.DecodeRune(src)
+
+			if sz == 1 {
+				// Invalid rune.
+				if !atEOF && !utf8.FullRune(src) {
+					err = ErrShortSrc
+					break
+				}
+				// We replace illegal bytes with RuneError. Not doing so might
+				// otherwise turn a sequence of invalid UTF-8 into valid UTF-8.
+				// The resulting byte sequence may subsequently contain runes
+				// for which t(r) is true that were passed unnoticed.
+				if !t(r) {
+					if nDst+3 > len(dst) {
+						err = ErrShortDst
+						break
+					}
+					nDst += copy(dst[nDst:], "\uFFFD")
+				}
+				nSrc++
+				continue
+			}
+		}
+
+		if !t(r) {
+			if nDst+sz > len(dst) {
+				err = ErrShortDst
+				break
+			}
+			nDst += copy(dst[nDst:], src[:sz])
+		}
+		nSrc += sz
+	}
+	return
+}
+
+// grow returns a new []byte that is longer than b, and copies the first n bytes
+// of b to the start of the new slice.
+func grow(b []byte, n int) []byte {
+	m := len(b)
+	if m <= 32 {
+		m = 64
+	} else if m <= 256 {
+		m *= 2
+	} else {
+		m += m >> 1
+	}
+	buf := make([]byte, m)
+	copy(buf, b[:n])
+	return buf
+}
+
+const initialBufSize = 128
+
+// String returns a string with the result of converting s[:n] using t, where
+// n <= len(s). If err == nil, n will be len(s). It calls Reset on t.
+func String(t Transformer, s string) (result string, n int, err error) {
+	t.Reset()
+	if s == "" {
+		// Fast path for the common case for empty input. Results in about a
+		// 86% reduction of running time for BenchmarkStringLowerEmpty.
+		if _, _, err := t.Transform(nil, nil, true); err == nil {
+			return "", 0, nil
+		}
+	}
+
+	// Allocate only once. Note that both dst and src escape when passed to
+	// Transform.
+	buf := [2 * initialBufSize]byte{}
+	dst := buf[:initialBufSize:initialBufSize]
+	src := buf[initialBufSize : 2*initialBufSize]
+
+	// The input string s is transformed in multiple chunks (starting with a
+	// chunk size of initialBufSize). nDst and nSrc are per-chunk (or
+	// per-Transform-call) indexes, pDst and pSrc are overall indexes.
+	nDst, nSrc := 0, 0
+	pDst, pSrc := 0, 0
+
+	// pPrefix is the length of a common prefix: the first pPrefix bytes of the
+	// result will equal the first pPrefix bytes of s. It is not guaranteed to
+	// be the largest such value, but if pPrefix, len(result) and len(s) are
+	// all equal after the final transform (i.e. calling Transform with atEOF
+	// being true returned nil error) then we don't need to allocate a new
+	// result string.
+	pPrefix := 0
+	for {
+		// Invariant: pDst == pPrefix && pSrc == pPrefix.
+
+		n := copy(src, s[pSrc:])
+		nDst, nSrc, err = t.Transform(dst, src[:n], pSrc+n == len(s))
+		pDst += nDst
+		pSrc += nSrc
+
+		// TODO:  let transformers implement an optional Spanner interface, akin
+		// to norm's QuickSpan. This would even allow us to avoid any allocation.
+		if !bytes.Equal(dst[:nDst], src[:nSrc]) {
+			break
+		}
+		pPrefix = pSrc
+		if err == ErrShortDst {
+			// A buffer can only be short if a transformer modifies its input.
+			break
+		} else if err == ErrShortSrc {
+			if nSrc == 0 {
+				// No progress was made.
+				break
+			}
+			// Equal so far and !atEOF, so continue checking.
+		} else if err != nil || pPrefix == len(s) {
+			return string(s[:pPrefix]), pPrefix, err
+		}
+	}
+	// Post-condition: pDst == pPrefix + nDst && pSrc == pPrefix + nSrc.
+
+	// We have transformed the first pSrc bytes of the input s to become pDst
+	// transformed bytes. Those transformed bytes are discontiguous: the first
+	// pPrefix of them equal s[:pPrefix] and the last nDst of them equal
+	// dst[:nDst]. We copy them around, into a new dst buffer if necessary, so
+	// that they become one contiguous slice: dst[:pDst].
+	if pPrefix != 0 {
+		newDst := dst
+		if pDst > len(newDst) {
+			newDst = make([]byte, len(s)+nDst-nSrc)
+		}
+		copy(newDst[pPrefix:pDst], dst[:nDst])
+		copy(newDst[:pPrefix], s[:pPrefix])
+		dst = newDst
+	}
+
+	// Prevent duplicate Transform calls with atEOF being true at the end of
+	// the input. Also return if we have an unrecoverable error.
+	if (err == nil && pSrc == len(s)) ||
+		(err != nil && err != ErrShortDst && err != ErrShortSrc) {
+		return string(dst[:pDst]), pSrc, err
+	}
+
+	// Transform the remaining input, growing dst and src buffers as necessary.
+	for {
+		n := copy(src, s[pSrc:])
+		nDst, nSrc, err := t.Transform(dst[pDst:], src[:n], pSrc+n == len(s))
+		pDst += nDst
+		pSrc += nSrc
+
+		// If we got ErrShortDst or ErrShortSrc, do not grow as long as we can
+		// make progress. This may avoid excessive allocations.
+		if err == ErrShortDst {
+			if nDst == 0 {
+				dst = grow(dst, pDst)
+			}
+		} else if err == ErrShortSrc {
+			if nSrc == 0 {
+				src = grow(src, 0)
+			}
+		} else if err != nil || pSrc == len(s) {
+			return string(dst[:pDst]), pSrc, err
+		}
+	}
+}
+
+// Bytes returns a new byte slice with the result of converting b[:n] using t,
+// where n <= len(b). If err == nil, n will be len(b). It calls Reset on t.
+func Bytes(t Transformer, b []byte) (result []byte, n int, err error) {
+	return doAppend(t, 0, make([]byte, len(b)), b)
+}
+
+// Append appends the result of converting src[:n] using t to dst, where
+// n <= len(src), If err == nil, n will be len(src). It calls Reset on t.
+func Append(t Transformer, dst, src []byte) (result []byte, n int, err error) {
+	if len(dst) == cap(dst) {
+		n := len(src) + len(dst) // It is okay for this to be 0.
+		b := make([]byte, n)
+		dst = b[:copy(b, dst)]
+	}
+	return doAppend(t, len(dst), dst[:cap(dst)], src)
+}
+
+func doAppend(t Transformer, pDst int, dst, src []byte) (result []byte, n int, err error) {
+	t.Reset()
+	pSrc := 0
+	for {
+		nDst, nSrc, err := t.Transform(dst[pDst:], src[pSrc:], true)
+		pDst += nDst
+		pSrc += nSrc
+		if err != ErrShortDst {
+			return dst[:pDst], pSrc, err
+		}
+
+		// Grow the destination buffer, but do not grow as long as we can make
+		// progress. This may avoid excessive allocations.
+		if nDst == 0 {
+			dst = grow(dst, pDst)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/composition.go b/vendor/golang.org/x/text/unicode/norm/composition.go
new file mode 100644
index 000000000..bab4c5de0
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/composition.go
@@ -0,0 +1,508 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+import "unicode/utf8"
+
+const (
+	maxNonStarters = 30
+	// The maximum number of characters needed for a buffer is
+	// maxNonStarters + 1 for the starter + 1 for the GCJ
+	maxBufferSize    = maxNonStarters + 2
+	maxNFCExpansion  = 3  // NFC(0x1D160)
+	maxNFKCExpansion = 18 // NFKC(0xFDFA)
+
+	maxByteBufferSize = utf8.UTFMax * maxBufferSize // 128
+)
+
+// ssState is used for reporting the segment state after inserting a rune.
+// It is returned by streamSafe.next.
+type ssState int
+
+const (
+	// Indicates a rune was successfully added to the segment.
+	ssSuccess ssState = iota
+	// Indicates a rune starts a new segment and should not be added.
+	ssStarter
+	// Indicates a rune caused a segment overflow and a CGJ should be inserted.
+	ssOverflow
+)
+
+// streamSafe implements the policy of when a CGJ should be inserted.
+type streamSafe uint8
+
+// first inserts the first rune of a segment. It is a faster version of next if
+// it is known p represents the first rune in a segment.
+func (ss *streamSafe) first(p Properties) {
+	*ss = streamSafe(p.nTrailingNonStarters())
+}
+
+// insert returns a ssState value to indicate whether a rune represented by p
+// can be inserted.
+func (ss *streamSafe) next(p Properties) ssState {
+	if *ss > maxNonStarters {
+		panic("streamSafe was not reset")
+	}
+	n := p.nLeadingNonStarters()
+	if *ss += streamSafe(n); *ss > maxNonStarters {
+		*ss = 0
+		return ssOverflow
+	}
+	// The Stream-Safe Text Processing prescribes that the counting can stop
+	// as soon as a starter is encountered. However, there are some starters,
+	// like Jamo V and T, that can combine with other runes, leaving their
+	// successive non-starters appended to the previous, possibly causing an
+	// overflow. We will therefore consider any rune with a non-zero nLead to
+	// be a non-starter. Note that it always hold that if nLead > 0 then
+	// nLead == nTrail.
+	if n == 0 {
+		*ss = streamSafe(p.nTrailingNonStarters())
+		return ssStarter
+	}
+	return ssSuccess
+}
+
+// backwards is used for checking for overflow and segment starts
+// when traversing a string backwards. Users do not need to call first
+// for the first rune. The state of the streamSafe retains the count of
+// the non-starters loaded.
+func (ss *streamSafe) backwards(p Properties) ssState {
+	if *ss > maxNonStarters {
+		panic("streamSafe was not reset")
+	}
+	c := *ss + streamSafe(p.nTrailingNonStarters())
+	if c > maxNonStarters {
+		return ssOverflow
+	}
+	*ss = c
+	if p.nLeadingNonStarters() == 0 {
+		return ssStarter
+	}
+	return ssSuccess
+}
+
+func (ss streamSafe) isMax() bool {
+	return ss == maxNonStarters
+}
+
+// GraphemeJoiner is inserted after maxNonStarters non-starter runes.
+const GraphemeJoiner = "\u034F"
+
+// reorderBuffer is used to normalize a single segment.  Characters inserted with
+// insert are decomposed and reordered based on CCC. The compose method can
+// be used to recombine characters.  Note that the byte buffer does not hold
+// the UTF-8 characters in order.  Only the rune array is maintained in sorted
+// order. flush writes the resulting segment to a byte array.
+type reorderBuffer struct {
+	rune  [maxBufferSize]Properties // Per character info.
+	byte  [maxByteBufferSize]byte   // UTF-8 buffer. Referenced by runeInfo.pos.
+	nbyte uint8                     // Number or bytes.
+	ss    streamSafe                // For limiting length of non-starter sequence.
+	nrune int                       // Number of runeInfos.
+	f     formInfo
+
+	src      input
+	nsrc     int
+	tmpBytes input
+
+	out    []byte
+	flushF func(*reorderBuffer) bool
+}
+
+func (rb *reorderBuffer) init(f Form, src []byte) {
+	rb.f = *formTable[f]
+	rb.src.setBytes(src)
+	rb.nsrc = len(src)
+	rb.ss = 0
+}
+
+func (rb *reorderBuffer) initString(f Form, src string) {
+	rb.f = *formTable[f]
+	rb.src.setString(src)
+	rb.nsrc = len(src)
+	rb.ss = 0
+}
+
+func (rb *reorderBuffer) setFlusher(out []byte, f func(*reorderBuffer) bool) {
+	rb.out = out
+	rb.flushF = f
+}
+
+// reset discards all characters from the buffer.
+func (rb *reorderBuffer) reset() {
+	rb.nrune = 0
+	rb.nbyte = 0
+}
+
+func (rb *reorderBuffer) doFlush() bool {
+	if rb.f.composing {
+		rb.compose()
+	}
+	res := rb.flushF(rb)
+	rb.reset()
+	return res
+}
+
+// appendFlush appends the normalized segment to rb.out.
+func appendFlush(rb *reorderBuffer) bool {
+	for i := 0; i < rb.nrune; i++ {
+		start := rb.rune[i].pos
+		end := start + rb.rune[i].size
+		rb.out = append(rb.out, rb.byte[start:end]...)
+	}
+	return true
+}
+
+// flush appends the normalized segment to out and resets rb.
+func (rb *reorderBuffer) flush(out []byte) []byte {
+	for i := 0; i < rb.nrune; i++ {
+		start := rb.rune[i].pos
+		end := start + rb.rune[i].size
+		out = append(out, rb.byte[start:end]...)
+	}
+	rb.reset()
+	return out
+}
+
+// flushCopy copies the normalized segment to buf and resets rb.
+// It returns the number of bytes written to buf.
+func (rb *reorderBuffer) flushCopy(buf []byte) int {
+	p := 0
+	for i := 0; i < rb.nrune; i++ {
+		runep := rb.rune[i]
+		p += copy(buf[p:], rb.byte[runep.pos:runep.pos+runep.size])
+	}
+	rb.reset()
+	return p
+}
+
+// insertOrdered inserts a rune in the buffer, ordered by Canonical Combining Class.
+// It returns false if the buffer is not large enough to hold the rune.
+// It is used internally by insert and insertString only.
+func (rb *reorderBuffer) insertOrdered(info Properties) {
+	n := rb.nrune
+	b := rb.rune[:]
+	cc := info.ccc
+	if cc > 0 {
+		// Find insertion position + move elements to make room.
+		for ; n > 0; n-- {
+			if b[n-1].ccc <= cc {
+				break
+			}
+			b[n] = b[n-1]
+		}
+	}
+	rb.nrune += 1
+	pos := uint8(rb.nbyte)
+	rb.nbyte += utf8.UTFMax
+	info.pos = pos
+	b[n] = info
+}
+
+// insertErr is an error code returned by insert. Using this type instead
+// of error improves performance up to 20% for many of the benchmarks.
+type insertErr int
+
+const (
+	iSuccess insertErr = -iota
+	iShortDst
+	iShortSrc
+)
+
+// insertFlush inserts the given rune in the buffer ordered by CCC.
+// If a decomposition with multiple segments are encountered, they leading
+// ones are flushed.
+// It returns a non-zero error code if the rune was not inserted.
+func (rb *reorderBuffer) insertFlush(src input, i int, info Properties) insertErr {
+	if rune := src.hangul(i); rune != 0 {
+		rb.decomposeHangul(rune)
+		return iSuccess
+	}
+	if info.hasDecomposition() {
+		return rb.insertDecomposed(info.Decomposition())
+	}
+	rb.insertSingle(src, i, info)
+	return iSuccess
+}
+
+// insertUnsafe inserts the given rune in the buffer ordered by CCC.
+// It is assumed there is sufficient space to hold the runes. It is the
+// responsibility of the caller to ensure this. This can be done by checking
+// the state returned by the streamSafe type.
+func (rb *reorderBuffer) insertUnsafe(src input, i int, info Properties) {
+	if rune := src.hangul(i); rune != 0 {
+		rb.decomposeHangul(rune)
+	}
+	if info.hasDecomposition() {
+		// TODO: inline.
+		rb.insertDecomposed(info.Decomposition())
+	} else {
+		rb.insertSingle(src, i, info)
+	}
+}
+
+// insertDecomposed inserts an entry in to the reorderBuffer for each rune
+// in dcomp. dcomp must be a sequence of decomposed UTF-8-encoded runes.
+// It flushes the buffer on each new segment start.
+func (rb *reorderBuffer) insertDecomposed(dcomp []byte) insertErr {
+	rb.tmpBytes.setBytes(dcomp)
+	// As the streamSafe accounting already handles the counting for modifiers,
+	// we don't have to call next. However, we do need to keep the accounting
+	// intact when flushing the buffer.
+	for i := 0; i < len(dcomp); {
+		info := rb.f.info(rb.tmpBytes, i)
+		if info.BoundaryBefore() && rb.nrune > 0 && !rb.doFlush() {
+			return iShortDst
+		}
+		i += copy(rb.byte[rb.nbyte:], dcomp[i:i+int(info.size)])
+		rb.insertOrdered(info)
+	}
+	return iSuccess
+}
+
+// insertSingle inserts an entry in the reorderBuffer for the rune at
+// position i. info is the runeInfo for the rune at position i.
+func (rb *reorderBuffer) insertSingle(src input, i int, info Properties) {
+	src.copySlice(rb.byte[rb.nbyte:], i, i+int(info.size))
+	rb.insertOrdered(info)
+}
+
+// insertCGJ inserts a Combining Grapheme Joiner (0x034f) into rb.
+func (rb *reorderBuffer) insertCGJ() {
+	rb.insertSingle(input{str: GraphemeJoiner}, 0, Properties{size: uint8(len(GraphemeJoiner))})
+}
+
+// appendRune inserts a rune at the end of the buffer. It is used for Hangul.
+func (rb *reorderBuffer) appendRune(r rune) {
+	bn := rb.nbyte
+	sz := utf8.EncodeRune(rb.byte[bn:], rune(r))
+	rb.nbyte += utf8.UTFMax
+	rb.rune[rb.nrune] = Properties{pos: bn, size: uint8(sz)}
+	rb.nrune++
+}
+
+// assignRune sets a rune at position pos. It is used for Hangul and recomposition.
+func (rb *reorderBuffer) assignRune(pos int, r rune) {
+	bn := rb.rune[pos].pos
+	sz := utf8.EncodeRune(rb.byte[bn:], rune(r))
+	rb.rune[pos] = Properties{pos: bn, size: uint8(sz)}
+}
+
+// runeAt returns the rune at position n. It is used for Hangul and recomposition.
+func (rb *reorderBuffer) runeAt(n int) rune {
+	inf := rb.rune[n]
+	r, _ := utf8.DecodeRune(rb.byte[inf.pos : inf.pos+inf.size])
+	return r
+}
+
+// bytesAt returns the UTF-8 encoding of the rune at position n.
+// It is used for Hangul and recomposition.
+func (rb *reorderBuffer) bytesAt(n int) []byte {
+	inf := rb.rune[n]
+	return rb.byte[inf.pos : int(inf.pos)+int(inf.size)]
+}
+
+// For Hangul we combine algorithmically, instead of using tables.
+const (
+	hangulBase  = 0xAC00 // UTF-8(hangulBase) -> EA B0 80
+	hangulBase0 = 0xEA
+	hangulBase1 = 0xB0
+	hangulBase2 = 0x80
+
+	hangulEnd  = hangulBase + jamoLVTCount // UTF-8(0xD7A4) -> ED 9E A4
+	hangulEnd0 = 0xED
+	hangulEnd1 = 0x9E
+	hangulEnd2 = 0xA4
+
+	jamoLBase  = 0x1100 // UTF-8(jamoLBase) -> E1 84 00
+	jamoLBase0 = 0xE1
+	jamoLBase1 = 0x84
+	jamoLEnd   = 0x1113
+	jamoVBase  = 0x1161
+	jamoVEnd   = 0x1176
+	jamoTBase  = 0x11A7
+	jamoTEnd   = 0x11C3
+
+	jamoTCount   = 28
+	jamoVCount   = 21
+	jamoVTCount  = 21 * 28
+	jamoLVTCount = 19 * 21 * 28
+)
+
+const hangulUTF8Size = 3
+
+func isHangul(b []byte) bool {
+	if len(b) < hangulUTF8Size {
+		return false
+	}
+	b0 := b[0]
+	if b0 < hangulBase0 {
+		return false
+	}
+	b1 := b[1]
+	switch {
+	case b0 == hangulBase0:
+		return b1 >= hangulBase1
+	case b0 < hangulEnd0:
+		return true
+	case b0 > hangulEnd0:
+		return false
+	case b1 < hangulEnd1:
+		return true
+	}
+	return b1 == hangulEnd1 && b[2] < hangulEnd2
+}
+
+func isHangulString(b string) bool {
+	if len(b) < hangulUTF8Size {
+		return false
+	}
+	b0 := b[0]
+	if b0 < hangulBase0 {
+		return false
+	}
+	b1 := b[1]
+	switch {
+	case b0 == hangulBase0:
+		return b1 >= hangulBase1
+	case b0 < hangulEnd0:
+		return true
+	case b0 > hangulEnd0:
+		return false
+	case b1 < hangulEnd1:
+		return true
+	}
+	return b1 == hangulEnd1 && b[2] < hangulEnd2
+}
+
+// Caller must ensure len(b) >= 2.
+func isJamoVT(b []byte) bool {
+	// True if (rune & 0xff00) == jamoLBase
+	return b[0] == jamoLBase0 && (b[1]&0xFC) == jamoLBase1
+}
+
+func isHangulWithoutJamoT(b []byte) bool {
+	c, _ := utf8.DecodeRune(b)
+	c -= hangulBase
+	return c < jamoLVTCount && c%jamoTCount == 0
+}
+
+// decomposeHangul writes the decomposed Hangul to buf and returns the number
+// of bytes written.  len(buf) should be at least 9.
+func decomposeHangul(buf []byte, r rune) int {
+	const JamoUTF8Len = 3
+	r -= hangulBase
+	x := r % jamoTCount
+	r /= jamoTCount
+	utf8.EncodeRune(buf, jamoLBase+r/jamoVCount)
+	utf8.EncodeRune(buf[JamoUTF8Len:], jamoVBase+r%jamoVCount)
+	if x != 0 {
+		utf8.EncodeRune(buf[2*JamoUTF8Len:], jamoTBase+x)
+		return 3 * JamoUTF8Len
+	}
+	return 2 * JamoUTF8Len
+}
+
+// decomposeHangul algorithmically decomposes a Hangul rune into
+// its Jamo components.
+// See http://unicode.org/reports/tr15/#Hangul for details on decomposing Hangul.
+func (rb *reorderBuffer) decomposeHangul(r rune) {
+	r -= hangulBase
+	x := r % jamoTCount
+	r /= jamoTCount
+	rb.appendRune(jamoLBase + r/jamoVCount)
+	rb.appendRune(jamoVBase + r%jamoVCount)
+	if x != 0 {
+		rb.appendRune(jamoTBase + x)
+	}
+}
+
+// combineHangul algorithmically combines Jamo character components into Hangul.
+// See http://unicode.org/reports/tr15/#Hangul for details on combining Hangul.
+func (rb *reorderBuffer) combineHangul(s, i, k int) {
+	b := rb.rune[:]
+	bn := rb.nrune
+	for ; i < bn; i++ {
+		cccB := b[k-1].ccc
+		cccC := b[i].ccc
+		if cccB == 0 {
+			s = k - 1
+		}
+		if s != k-1 && cccB >= cccC {
+			// b[i] is blocked by greater-equal cccX below it
+			b[k] = b[i]
+			k++
+		} else {
+			l := rb.runeAt(s) // also used to compare to hangulBase
+			v := rb.runeAt(i) // also used to compare to jamoT
+			switch {
+			case jamoLBase <= l && l < jamoLEnd &&
+				jamoVBase <= v && v < jamoVEnd:
+				// 11xx plus 116x to LV
+				rb.assignRune(s, hangulBase+
+					(l-jamoLBase)*jamoVTCount+(v-jamoVBase)*jamoTCount)
+			case hangulBase <= l && l < hangulEnd &&
+				jamoTBase < v && v < jamoTEnd &&
+				((l-hangulBase)%jamoTCount) == 0:
+				// ACxx plus 11Ax to LVT
+				rb.assignRune(s, l+v-jamoTBase)
+			default:
+				b[k] = b[i]
+				k++
+			}
+		}
+	}
+	rb.nrune = k
+}
+
+// compose recombines the runes in the buffer.
+// It should only be used to recompose a single segment, as it will not
+// handle alternations between Hangul and non-Hangul characters correctly.
+func (rb *reorderBuffer) compose() {
+	// UAX #15, section X5 , including Corrigendum #5
+	// "In any character sequence beginning with starter S, a character C is
+	//  blocked from S if and only if there is some character B between S
+	//  and C, and either B is a starter or it has the same or higher
+	//  combining class as C."
+	bn := rb.nrune
+	if bn == 0 {
+		return
+	}
+	k := 1
+	b := rb.rune[:]
+	for s, i := 0, 1; i < bn; i++ {
+		if isJamoVT(rb.bytesAt(i)) {
+			// Redo from start in Hangul mode. Necessary to support
+			// U+320E..U+321E in NFKC mode.
+			rb.combineHangul(s, i, k)
+			return
+		}
+		ii := b[i]
+		// We can only use combineForward as a filter if we later
+		// get the info for the combined character. This is more
+		// expensive than using the filter. Using combinesBackward()
+		// is safe.
+		if ii.combinesBackward() {
+			cccB := b[k-1].ccc
+			cccC := ii.ccc
+			blocked := false // b[i] blocked by starter or greater or equal CCC?
+			if cccB == 0 {
+				s = k - 1
+			} else {
+				blocked = s != k-1 && cccB >= cccC
+			}
+			if !blocked {
+				combined := combine(rb.runeAt(s), rb.runeAt(i))
+				if combined != 0 {
+					rb.assignRune(s, combined)
+					continue
+				}
+			}
+		}
+		b[k] = b[i]
+		k++
+	}
+	rb.nrune = k
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/forminfo.go b/vendor/golang.org/x/text/unicode/norm/forminfo.go
new file mode 100644
index 000000000..e67e7655c
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/forminfo.go
@@ -0,0 +1,259 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+// This file contains Form-specific logic and wrappers for data in tables.go.
+
+// Rune info is stored in a separate trie per composing form. A composing form
+// and its corresponding decomposing form share the same trie.  Each trie maps
+// a rune to a uint16. The values take two forms.  For v >= 0x8000:
+//   bits
+//   15:    1 (inverse of NFD_QC bit of qcInfo)
+//   13..7: qcInfo (see below). isYesD is always true (no decompostion).
+//    6..0: ccc (compressed CCC value).
+// For v < 0x8000, the respective rune has a decomposition and v is an index
+// into a byte array of UTF-8 decomposition sequences and additional info and
+// has the form:
+//    <header> <decomp_byte>* [<tccc> [<lccc>]]
+// The header contains the number of bytes in the decomposition (excluding this
+// length byte). The two most significant bits of this length byte correspond
+// to bit 5 and 4 of qcInfo (see below).  The byte sequence itself starts at v+1.
+// The byte sequence is followed by a trailing and leading CCC if the values
+// for these are not zero.  The value of v determines which ccc are appended
+// to the sequences.  For v < firstCCC, there are none, for v >= firstCCC,
+// the sequence is followed by a trailing ccc, and for v >= firstLeadingCC
+// there is an additional leading ccc. The value of tccc itself is the
+// trailing CCC shifted left 2 bits. The two least-significant bits of tccc
+// are the number of trailing non-starters.
+
+const (
+	qcInfoMask      = 0x3F // to clear all but the relevant bits in a qcInfo
+	headerLenMask   = 0x3F // extract the length value from the header byte
+	headerFlagsMask = 0xC0 // extract the qcInfo bits from the header byte
+)
+
+// Properties provides access to normalization properties of a rune.
+type Properties struct {
+	pos   uint8  // start position in reorderBuffer; used in composition.go
+	size  uint8  // length of UTF-8 encoding of this rune
+	ccc   uint8  // leading canonical combining class (ccc if not decomposition)
+	tccc  uint8  // trailing canonical combining class (ccc if not decomposition)
+	nLead uint8  // number of leading non-starters.
+	flags qcInfo // quick check flags
+	index uint16
+}
+
+// functions dispatchable per form
+type lookupFunc func(b input, i int) Properties
+
+// formInfo holds Form-specific functions and tables.
+type formInfo struct {
+	form                     Form
+	composing, compatibility bool // form type
+	info                     lookupFunc
+	nextMain                 iterFunc
+}
+
+var formTable = []*formInfo{{
+	form:          NFC,
+	composing:     true,
+	compatibility: false,
+	info:          lookupInfoNFC,
+	nextMain:      nextComposed,
+}, {
+	form:          NFD,
+	composing:     false,
+	compatibility: false,
+	info:          lookupInfoNFC,
+	nextMain:      nextDecomposed,
+}, {
+	form:          NFKC,
+	composing:     true,
+	compatibility: true,
+	info:          lookupInfoNFKC,
+	nextMain:      nextComposed,
+}, {
+	form:          NFKD,
+	composing:     false,
+	compatibility: true,
+	info:          lookupInfoNFKC,
+	nextMain:      nextDecomposed,
+}}
+
+// We do not distinguish between boundaries for NFC, NFD, etc. to avoid
+// unexpected behavior for the user.  For example, in NFD, there is a boundary
+// after 'a'.  However, 'a' might combine with modifiers, so from the application's
+// perspective it is not a good boundary. We will therefore always use the
+// boundaries for the combining variants.
+
+// BoundaryBefore returns true if this rune starts a new segment and
+// cannot combine with any rune on the left.
+func (p Properties) BoundaryBefore() bool {
+	if p.ccc == 0 && !p.combinesBackward() {
+		return true
+	}
+	// We assume that the CCC of the first character in a decomposition
+	// is always non-zero if different from info.ccc and that we can return
+	// false at this point. This is verified by maketables.
+	return false
+}
+
+// BoundaryAfter returns true if runes cannot combine with or otherwise
+// interact with this or previous runes.
+func (p Properties) BoundaryAfter() bool {
+	// TODO: loosen these conditions.
+	return p.isInert()
+}
+
+// We pack quick check data in 4 bits:
+//   5:    Combines forward  (0 == false, 1 == true)
+//   4..3: NFC_QC Yes(00), No (10), or Maybe (11)
+//   2:    NFD_QC Yes (0) or No (1). No also means there is a decomposition.
+//   1..0: Number of trailing non-starters.
+//
+// When all 4 bits are zero, the character is inert, meaning it is never
+// influenced by normalization.
+type qcInfo uint8
+
+func (p Properties) isYesC() bool { return p.flags&0x10 == 0 }
+func (p Properties) isYesD() bool { return p.flags&0x4 == 0 }
+
+func (p Properties) combinesForward() bool  { return p.flags&0x20 != 0 }
+func (p Properties) combinesBackward() bool { return p.flags&0x8 != 0 } // == isMaybe
+func (p Properties) hasDecomposition() bool { return p.flags&0x4 != 0 } // == isNoD
+
+func (p Properties) isInert() bool {
+	return p.flags&qcInfoMask == 0 && p.ccc == 0
+}
+
+func (p Properties) multiSegment() bool {
+	return p.index >= firstMulti && p.index < endMulti
+}
+
+func (p Properties) nLeadingNonStarters() uint8 {
+	return p.nLead
+}
+
+func (p Properties) nTrailingNonStarters() uint8 {
+	return uint8(p.flags & 0x03)
+}
+
+// Decomposition returns the decomposition for the underlying rune
+// or nil if there is none.
+func (p Properties) Decomposition() []byte {
+	// TODO: create the decomposition for Hangul?
+	if p.index == 0 {
+		return nil
+	}
+	i := p.index
+	n := decomps[i] & headerLenMask
+	i++
+	return decomps[i : i+uint16(n)]
+}
+
+// Size returns the length of UTF-8 encoding of the rune.
+func (p Properties) Size() int {
+	return int(p.size)
+}
+
+// CCC returns the canonical combining class of the underlying rune.
+func (p Properties) CCC() uint8 {
+	if p.index >= firstCCCZeroExcept {
+		return 0
+	}
+	return ccc[p.ccc]
+}
+
+// LeadCCC returns the CCC of the first rune in the decomposition.
+// If there is no decomposition, LeadCCC equals CCC.
+func (p Properties) LeadCCC() uint8 {
+	return ccc[p.ccc]
+}
+
+// TrailCCC returns the CCC of the last rune in the decomposition.
+// If there is no decomposition, TrailCCC equals CCC.
+func (p Properties) TrailCCC() uint8 {
+	return ccc[p.tccc]
+}
+
+// Recomposition
+// We use 32-bit keys instead of 64-bit for the two codepoint keys.
+// This clips off the bits of three entries, but we know this will not
+// result in a collision. In the unlikely event that changes to
+// UnicodeData.txt introduce collisions, the compiler will catch it.
+// Note that the recomposition map for NFC and NFKC are identical.
+
+// combine returns the combined rune or 0 if it doesn't exist.
+func combine(a, b rune) rune {
+	key := uint32(uint16(a))<<16 + uint32(uint16(b))
+	return recompMap[key]
+}
+
+func lookupInfoNFC(b input, i int) Properties {
+	v, sz := b.charinfoNFC(i)
+	return compInfo(v, sz)
+}
+
+func lookupInfoNFKC(b input, i int) Properties {
+	v, sz := b.charinfoNFKC(i)
+	return compInfo(v, sz)
+}
+
+// Properties returns properties for the first rune in s.
+func (f Form) Properties(s []byte) Properties {
+	if f == NFC || f == NFD {
+		return compInfo(nfcData.lookup(s))
+	}
+	return compInfo(nfkcData.lookup(s))
+}
+
+// PropertiesString returns properties for the first rune in s.
+func (f Form) PropertiesString(s string) Properties {
+	if f == NFC || f == NFD {
+		return compInfo(nfcData.lookupString(s))
+	}
+	return compInfo(nfkcData.lookupString(s))
+}
+
+// compInfo converts the information contained in v and sz
+// to a Properties.  See the comment at the top of the file
+// for more information on the format.
+func compInfo(v uint16, sz int) Properties {
+	if v == 0 {
+		return Properties{size: uint8(sz)}
+	} else if v >= 0x8000 {
+		p := Properties{
+			size:  uint8(sz),
+			ccc:   uint8(v),
+			tccc:  uint8(v),
+			flags: qcInfo(v >> 8),
+		}
+		if p.ccc > 0 || p.combinesBackward() {
+			p.nLead = uint8(p.flags & 0x3)
+		}
+		return p
+	}
+	// has decomposition
+	h := decomps[v]
+	f := (qcInfo(h&headerFlagsMask) >> 2) | 0x4
+	p := Properties{size: uint8(sz), flags: f, index: v}
+	if v >= firstCCC {
+		v += uint16(h&headerLenMask) + 1
+		c := decomps[v]
+		p.tccc = c >> 2
+		p.flags |= qcInfo(c & 0x3)
+		if v >= firstLeadingCCC {
+			p.nLead = c & 0x3
+			if v >= firstStarterWithNLead {
+				// We were tricked. Remove the decomposition.
+				p.flags &= 0x03
+				p.index = 0
+				return p
+			}
+			p.ccc = decomps[v+1]
+		}
+	}
+	return p
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/input.go b/vendor/golang.org/x/text/unicode/norm/input.go
new file mode 100644
index 000000000..479e35bc2
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/input.go
@@ -0,0 +1,109 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+import "unicode/utf8"
+
+type input struct {
+	str   string
+	bytes []byte
+}
+
+func inputBytes(str []byte) input {
+	return input{bytes: str}
+}
+
+func inputString(str string) input {
+	return input{str: str}
+}
+
+func (in *input) setBytes(str []byte) {
+	in.str = ""
+	in.bytes = str
+}
+
+func (in *input) setString(str string) {
+	in.str = str
+	in.bytes = nil
+}
+
+func (in *input) _byte(p int) byte {
+	if in.bytes == nil {
+		return in.str[p]
+	}
+	return in.bytes[p]
+}
+
+func (in *input) skipASCII(p, max int) int {
+	if in.bytes == nil {
+		for ; p < max && in.str[p] < utf8.RuneSelf; p++ {
+		}
+	} else {
+		for ; p < max && in.bytes[p] < utf8.RuneSelf; p++ {
+		}
+	}
+	return p
+}
+
+func (in *input) skipContinuationBytes(p int) int {
+	if in.bytes == nil {
+		for ; p < len(in.str) && !utf8.RuneStart(in.str[p]); p++ {
+		}
+	} else {
+		for ; p < len(in.bytes) && !utf8.RuneStart(in.bytes[p]); p++ {
+		}
+	}
+	return p
+}
+
+func (in *input) appendSlice(buf []byte, b, e int) []byte {
+	if in.bytes != nil {
+		return append(buf, in.bytes[b:e]...)
+	}
+	for i := b; i < e; i++ {
+		buf = append(buf, in.str[i])
+	}
+	return buf
+}
+
+func (in *input) copySlice(buf []byte, b, e int) int {
+	if in.bytes == nil {
+		return copy(buf, in.str[b:e])
+	}
+	return copy(buf, in.bytes[b:e])
+}
+
+func (in *input) charinfoNFC(p int) (uint16, int) {
+	if in.bytes == nil {
+		return nfcData.lookupString(in.str[p:])
+	}
+	return nfcData.lookup(in.bytes[p:])
+}
+
+func (in *input) charinfoNFKC(p int) (uint16, int) {
+	if in.bytes == nil {
+		return nfkcData.lookupString(in.str[p:])
+	}
+	return nfkcData.lookup(in.bytes[p:])
+}
+
+func (in *input) hangul(p int) (r rune) {
+	var size int
+	if in.bytes == nil {
+		if !isHangulString(in.str[p:]) {
+			return 0
+		}
+		r, size = utf8.DecodeRuneInString(in.str[p:])
+	} else {
+		if !isHangul(in.bytes[p:]) {
+			return 0
+		}
+		r, size = utf8.DecodeRune(in.bytes[p:])
+	}
+	if size != hangulUTF8Size {
+		return 0
+	}
+	return r
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/iter.go b/vendor/golang.org/x/text/unicode/norm/iter.go
new file mode 100644
index 000000000..ce17f96c2
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/iter.go
@@ -0,0 +1,457 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+import (
+	"fmt"
+	"unicode/utf8"
+)
+
+// MaxSegmentSize is the maximum size of a byte buffer needed to consider any
+// sequence of starter and non-starter runes for the purpose of normalization.
+const MaxSegmentSize = maxByteBufferSize
+
+// An Iter iterates over a string or byte slice, while normalizing it
+// to a given Form.
+type Iter struct {
+	rb     reorderBuffer
+	buf    [maxByteBufferSize]byte
+	info   Properties // first character saved from previous iteration
+	next   iterFunc   // implementation of next depends on form
+	asciiF iterFunc
+
+	p        int    // current position in input source
+	multiSeg []byte // remainder of multi-segment decomposition
+}
+
+type iterFunc func(*Iter) []byte
+
+// Init initializes i to iterate over src after normalizing it to Form f.
+func (i *Iter) Init(f Form, src []byte) {
+	i.p = 0
+	if len(src) == 0 {
+		i.setDone()
+		i.rb.nsrc = 0
+		return
+	}
+	i.multiSeg = nil
+	i.rb.init(f, src)
+	i.next = i.rb.f.nextMain
+	i.asciiF = nextASCIIBytes
+	i.info = i.rb.f.info(i.rb.src, i.p)
+	i.rb.ss.first(i.info)
+}
+
+// InitString initializes i to iterate over src after normalizing it to Form f.
+func (i *Iter) InitString(f Form, src string) {
+	i.p = 0
+	if len(src) == 0 {
+		i.setDone()
+		i.rb.nsrc = 0
+		return
+	}
+	i.multiSeg = nil
+	i.rb.initString(f, src)
+	i.next = i.rb.f.nextMain
+	i.asciiF = nextASCIIString
+	i.info = i.rb.f.info(i.rb.src, i.p)
+	i.rb.ss.first(i.info)
+}
+
+// Seek sets the segment to be returned by the next call to Next to start
+// at position p.  It is the responsibility of the caller to set p to the
+// start of a segment.
+func (i *Iter) Seek(offset int64, whence int) (int64, error) {
+	var abs int64
+	switch whence {
+	case 0:
+		abs = offset
+	case 1:
+		abs = int64(i.p) + offset
+	case 2:
+		abs = int64(i.rb.nsrc) + offset
+	default:
+		return 0, fmt.Errorf("norm: invalid whence")
+	}
+	if abs < 0 {
+		return 0, fmt.Errorf("norm: negative position")
+	}
+	if int(abs) >= i.rb.nsrc {
+		i.setDone()
+		return int64(i.p), nil
+	}
+	i.p = int(abs)
+	i.multiSeg = nil
+	i.next = i.rb.f.nextMain
+	i.info = i.rb.f.info(i.rb.src, i.p)
+	i.rb.ss.first(i.info)
+	return abs, nil
+}
+
+// returnSlice returns a slice of the underlying input type as a byte slice.
+// If the underlying is of type []byte, it will simply return a slice.
+// If the underlying is of type string, it will copy the slice to the buffer
+// and return that.
+func (i *Iter) returnSlice(a, b int) []byte {
+	if i.rb.src.bytes == nil {
+		return i.buf[:copy(i.buf[:], i.rb.src.str[a:b])]
+	}
+	return i.rb.src.bytes[a:b]
+}
+
+// Pos returns the byte position at which the next call to Next will commence processing.
+func (i *Iter) Pos() int {
+	return i.p
+}
+
+func (i *Iter) setDone() {
+	i.next = nextDone
+	i.p = i.rb.nsrc
+}
+
+// Done returns true if there is no more input to process.
+func (i *Iter) Done() bool {
+	return i.p >= i.rb.nsrc
+}
+
+// Next returns f(i.input[i.Pos():n]), where n is a boundary of i.input.
+// For any input a and b for which f(a) == f(b), subsequent calls
+// to Next will return the same segments.
+// Modifying runes are grouped together with the preceding starter, if such a starter exists.
+// Although not guaranteed, n will typically be the smallest possible n.
+func (i *Iter) Next() []byte {
+	return i.next(i)
+}
+
+func nextASCIIBytes(i *Iter) []byte {
+	p := i.p + 1
+	if p >= i.rb.nsrc {
+		i.setDone()
+		return i.rb.src.bytes[i.p:p]
+	}
+	if i.rb.src.bytes[p] < utf8.RuneSelf {
+		p0 := i.p
+		i.p = p
+		return i.rb.src.bytes[p0:p]
+	}
+	i.info = i.rb.f.info(i.rb.src, i.p)
+	i.next = i.rb.f.nextMain
+	return i.next(i)
+}
+
+func nextASCIIString(i *Iter) []byte {
+	p := i.p + 1
+	if p >= i.rb.nsrc {
+		i.buf[0] = i.rb.src.str[i.p]
+		i.setDone()
+		return i.buf[:1]
+	}
+	if i.rb.src.str[p] < utf8.RuneSelf {
+		i.buf[0] = i.rb.src.str[i.p]
+		i.p = p
+		return i.buf[:1]
+	}
+	i.info = i.rb.f.info(i.rb.src, i.p)
+	i.next = i.rb.f.nextMain
+	return i.next(i)
+}
+
+func nextHangul(i *Iter) []byte {
+	p := i.p
+	next := p + hangulUTF8Size
+	if next >= i.rb.nsrc {
+		i.setDone()
+	} else if i.rb.src.hangul(next) == 0 {
+		i.rb.ss.next(i.info)
+		i.info = i.rb.f.info(i.rb.src, i.p)
+		i.next = i.rb.f.nextMain
+		return i.next(i)
+	}
+	i.p = next
+	return i.buf[:decomposeHangul(i.buf[:], i.rb.src.hangul(p))]
+}
+
+func nextDone(i *Iter) []byte {
+	return nil
+}
+
+// nextMulti is used for iterating over multi-segment decompositions
+// for decomposing normal forms.
+func nextMulti(i *Iter) []byte {
+	j := 0
+	d := i.multiSeg
+	// skip first rune
+	for j = 1; j < len(d) && !utf8.RuneStart(d[j]); j++ {
+	}
+	for j < len(d) {
+		info := i.rb.f.info(input{bytes: d}, j)
+		if info.BoundaryBefore() {
+			i.multiSeg = d[j:]
+			return d[:j]
+		}
+		j += int(info.size)
+	}
+	// treat last segment as normal decomposition
+	i.next = i.rb.f.nextMain
+	return i.next(i)
+}
+
+// nextMultiNorm is used for iterating over multi-segment decompositions
+// for composing normal forms.
+func nextMultiNorm(i *Iter) []byte {
+	j := 0
+	d := i.multiSeg
+	for j < len(d) {
+		info := i.rb.f.info(input{bytes: d}, j)
+		if info.BoundaryBefore() {
+			i.rb.compose()
+			seg := i.buf[:i.rb.flushCopy(i.buf[:])]
+			i.rb.insertUnsafe(input{bytes: d}, j, info)
+			i.multiSeg = d[j+int(info.size):]
+			return seg
+		}
+		i.rb.insertUnsafe(input{bytes: d}, j, info)
+		j += int(info.size)
+	}
+	i.multiSeg = nil
+	i.next = nextComposed
+	return doNormComposed(i)
+}
+
+// nextDecomposed is the implementation of Next for forms NFD and NFKD.
+func nextDecomposed(i *Iter) (next []byte) {
+	outp := 0
+	inCopyStart, outCopyStart := i.p, 0
+	for {
+		if sz := int(i.info.size); sz <= 1 {
+			i.rb.ss = 0
+			p := i.p
+			i.p++ // ASCII or illegal byte.  Either way, advance by 1.
+			if i.p >= i.rb.nsrc {
+				i.setDone()
+				return i.returnSlice(p, i.p)
+			} else if i.rb.src._byte(i.p) < utf8.RuneSelf {
+				i.next = i.asciiF
+				return i.returnSlice(p, i.p)
+			}
+			outp++
+		} else if d := i.info.Decomposition(); d != nil {
+			// Note: If leading CCC != 0, then len(d) == 2 and last is also non-zero.
+			// Case 1: there is a leftover to copy.  In this case the decomposition
+			// must begin with a modifier and should always be appended.
+			// Case 2: no leftover. Simply return d if followed by a ccc == 0 value.
+			p := outp + len(d)
+			if outp > 0 {
+				i.rb.src.copySlice(i.buf[outCopyStart:], inCopyStart, i.p)
+				// TODO: this condition should not be possible, but we leave it
+				// in for defensive purposes.
+				if p > len(i.buf) {
+					return i.buf[:outp]
+				}
+			} else if i.info.multiSegment() {
+				// outp must be 0 as multi-segment decompositions always
+				// start a new segment.
+				if i.multiSeg == nil {
+					i.multiSeg = d
+					i.next = nextMulti
+					return nextMulti(i)
+				}
+				// We are in the last segment.  Treat as normal decomposition.
+				d = i.multiSeg
+				i.multiSeg = nil
+				p = len(d)
+			}
+			prevCC := i.info.tccc
+			if i.p += sz; i.p >= i.rb.nsrc {
+				i.setDone()
+				i.info = Properties{} // Force BoundaryBefore to succeed.
+			} else {
+				i.info = i.rb.f.info(i.rb.src, i.p)
+			}
+			switch i.rb.ss.next(i.info) {
+			case ssOverflow:
+				i.next = nextCGJDecompose
+				fallthrough
+			case ssStarter:
+				if outp > 0 {
+					copy(i.buf[outp:], d)
+					return i.buf[:p]
+				}
+				return d
+			}
+			copy(i.buf[outp:], d)
+			outp = p
+			inCopyStart, outCopyStart = i.p, outp
+			if i.info.ccc < prevCC {
+				goto doNorm
+			}
+			continue
+		} else if r := i.rb.src.hangul(i.p); r != 0 {
+			outp = decomposeHangul(i.buf[:], r)
+			i.p += hangulUTF8Size
+			inCopyStart, outCopyStart = i.p, outp
+			if i.p >= i.rb.nsrc {
+				i.setDone()
+				break
+			} else if i.rb.src.hangul(i.p) != 0 {
+				i.next = nextHangul
+				return i.buf[:outp]
+			}
+		} else {
+			p := outp + sz
+			if p > len(i.buf) {
+				break
+			}
+			outp = p
+			i.p += sz
+		}
+		if i.p >= i.rb.nsrc {
+			i.setDone()
+			break
+		}
+		prevCC := i.info.tccc
+		i.info = i.rb.f.info(i.rb.src, i.p)
+		if v := i.rb.ss.next(i.info); v == ssStarter {
+			break
+		} else if v == ssOverflow {
+			i.next = nextCGJDecompose
+			break
+		}
+		if i.info.ccc < prevCC {
+			goto doNorm
+		}
+	}
+	if outCopyStart == 0 {
+		return i.returnSlice(inCopyStart, i.p)
+	} else if inCopyStart < i.p {
+		i.rb.src.copySlice(i.buf[outCopyStart:], inCopyStart, i.p)
+	}
+	return i.buf[:outp]
+doNorm:
+	// Insert what we have decomposed so far in the reorderBuffer.
+	// As we will only reorder, there will always be enough room.
+	i.rb.src.copySlice(i.buf[outCopyStart:], inCopyStart, i.p)
+	i.rb.insertDecomposed(i.buf[0:outp])
+	return doNormDecomposed(i)
+}
+
+func doNormDecomposed(i *Iter) []byte {
+	for {
+		i.rb.insertUnsafe(i.rb.src, i.p, i.info)
+		if i.p += int(i.info.size); i.p >= i.rb.nsrc {
+			i.setDone()
+			break
+		}
+		i.info = i.rb.f.info(i.rb.src, i.p)
+		if i.info.ccc == 0 {
+			break
+		}
+		if s := i.rb.ss.next(i.info); s == ssOverflow {
+			i.next = nextCGJDecompose
+			break
+		}
+	}
+	// new segment or too many combining characters: exit normalization
+	return i.buf[:i.rb.flushCopy(i.buf[:])]
+}
+
+func nextCGJDecompose(i *Iter) []byte {
+	i.rb.ss = 0
+	i.rb.insertCGJ()
+	i.next = nextDecomposed
+	i.rb.ss.first(i.info)
+	buf := doNormDecomposed(i)
+	return buf
+}
+
+// nextComposed is the implementation of Next for forms NFC and NFKC.
+func nextComposed(i *Iter) []byte {
+	outp, startp := 0, i.p
+	var prevCC uint8
+	for {
+		if !i.info.isYesC() {
+			goto doNorm
+		}
+		prevCC = i.info.tccc
+		sz := int(i.info.size)
+		if sz == 0 {
+			sz = 1 // illegal rune: copy byte-by-byte
+		}
+		p := outp + sz
+		if p > len(i.buf) {
+			break
+		}
+		outp = p
+		i.p += sz
+		if i.p >= i.rb.nsrc {
+			i.setDone()
+			break
+		} else if i.rb.src._byte(i.p) < utf8.RuneSelf {
+			i.rb.ss = 0
+			i.next = i.asciiF
+			break
+		}
+		i.info = i.rb.f.info(i.rb.src, i.p)
+		if v := i.rb.ss.next(i.info); v == ssStarter {
+			break
+		} else if v == ssOverflow {
+			i.next = nextCGJCompose
+			break
+		}
+		if i.info.ccc < prevCC {
+			goto doNorm
+		}
+	}
+	return i.returnSlice(startp, i.p)
+doNorm:
+	// reset to start position
+	i.p = startp
+	i.info = i.rb.f.info(i.rb.src, i.p)
+	i.rb.ss.first(i.info)
+	if i.info.multiSegment() {
+		d := i.info.Decomposition()
+		info := i.rb.f.info(input{bytes: d}, 0)
+		i.rb.insertUnsafe(input{bytes: d}, 0, info)
+		i.multiSeg = d[int(info.size):]
+		i.next = nextMultiNorm
+		return nextMultiNorm(i)
+	}
+	i.rb.ss.first(i.info)
+	i.rb.insertUnsafe(i.rb.src, i.p, i.info)
+	return doNormComposed(i)
+}
+
+func doNormComposed(i *Iter) []byte {
+	// First rune should already be inserted.
+	for {
+		if i.p += int(i.info.size); i.p >= i.rb.nsrc {
+			i.setDone()
+			break
+		}
+		i.info = i.rb.f.info(i.rb.src, i.p)
+		if s := i.rb.ss.next(i.info); s == ssStarter {
+			break
+		} else if s == ssOverflow {
+			i.next = nextCGJCompose
+			break
+		}
+		i.rb.insertUnsafe(i.rb.src, i.p, i.info)
+	}
+	i.rb.compose()
+	seg := i.buf[:i.rb.flushCopy(i.buf[:])]
+	return seg
+}
+
+func nextCGJCompose(i *Iter) []byte {
+	i.rb.ss = 0 // instead of first
+	i.rb.insertCGJ()
+	i.next = nextComposed
+	// Note that we treat any rune with nLeadingNonStarters > 0 as a non-starter,
+	// even if they are not. This is particularly dubious for U+FF9E and UFF9A.
+	// If we ever change that, insert a check here.
+	i.rb.ss.first(i.info)
+	i.rb.insertUnsafe(i.rb.src, i.p, i.info)
+	return doNormComposed(i)
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/normalize.go b/vendor/golang.org/x/text/unicode/norm/normalize.go
new file mode 100644
index 000000000..e28ac641a
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/normalize.go
@@ -0,0 +1,609 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Note: the file data_test.go that is generated should not be checked in.
+//go:generate go run maketables.go triegen.go
+//go:generate go test -tags test
+
+// Package norm contains types and functions for normalizing Unicode strings.
+package norm // import "golang.org/x/text/unicode/norm"
+
+import (
+	"unicode/utf8"
+
+	"golang.org/x/text/transform"
+)
+
+// A Form denotes a canonical representation of Unicode code points.
+// The Unicode-defined normalization and equivalence forms are:
+//
+//   NFC   Unicode Normalization Form C
+//   NFD   Unicode Normalization Form D
+//   NFKC  Unicode Normalization Form KC
+//   NFKD  Unicode Normalization Form KD
+//
+// For a Form f, this documentation uses the notation f(x) to mean
+// the bytes or string x converted to the given form.
+// A position n in x is called a boundary if conversion to the form can
+// proceed independently on both sides:
+//   f(x) == append(f(x[0:n]), f(x[n:])...)
+//
+// References: http://unicode.org/reports/tr15/ and
+// http://unicode.org/notes/tn5/.
+type Form int
+
+const (
+	NFC Form = iota
+	NFD
+	NFKC
+	NFKD
+)
+
+// Bytes returns f(b). May return b if f(b) = b.
+func (f Form) Bytes(b []byte) []byte {
+	src := inputBytes(b)
+	ft := formTable[f]
+	n, ok := ft.quickSpan(src, 0, len(b), true)
+	if ok {
+		return b
+	}
+	out := make([]byte, n, len(b))
+	copy(out, b[0:n])
+	rb := reorderBuffer{f: *ft, src: src, nsrc: len(b), out: out, flushF: appendFlush}
+	return doAppendInner(&rb, n)
+}
+
+// String returns f(s).
+func (f Form) String(s string) string {
+	src := inputString(s)
+	ft := formTable[f]
+	n, ok := ft.quickSpan(src, 0, len(s), true)
+	if ok {
+		return s
+	}
+	out := make([]byte, n, len(s))
+	copy(out, s[0:n])
+	rb := reorderBuffer{f: *ft, src: src, nsrc: len(s), out: out, flushF: appendFlush}
+	return string(doAppendInner(&rb, n))
+}
+
+// IsNormal returns true if b == f(b).
+func (f Form) IsNormal(b []byte) bool {
+	src := inputBytes(b)
+	ft := formTable[f]
+	bp, ok := ft.quickSpan(src, 0, len(b), true)
+	if ok {
+		return true
+	}
+	rb := reorderBuffer{f: *ft, src: src, nsrc: len(b)}
+	rb.setFlusher(nil, cmpNormalBytes)
+	for bp < len(b) {
+		rb.out = b[bp:]
+		if bp = decomposeSegment(&rb, bp, true); bp < 0 {
+			return false
+		}
+		bp, _ = rb.f.quickSpan(rb.src, bp, len(b), true)
+	}
+	return true
+}
+
+func cmpNormalBytes(rb *reorderBuffer) bool {
+	b := rb.out
+	for i := 0; i < rb.nrune; i++ {
+		info := rb.rune[i]
+		if int(info.size) > len(b) {
+			return false
+		}
+		p := info.pos
+		pe := p + info.size
+		for ; p < pe; p++ {
+			if b[0] != rb.byte[p] {
+				return false
+			}
+			b = b[1:]
+		}
+	}
+	return true
+}
+
+// IsNormalString returns true if s == f(s).
+func (f Form) IsNormalString(s string) bool {
+	src := inputString(s)
+	ft := formTable[f]
+	bp, ok := ft.quickSpan(src, 0, len(s), true)
+	if ok {
+		return true
+	}
+	rb := reorderBuffer{f: *ft, src: src, nsrc: len(s)}
+	rb.setFlusher(nil, func(rb *reorderBuffer) bool {
+		for i := 0; i < rb.nrune; i++ {
+			info := rb.rune[i]
+			if bp+int(info.size) > len(s) {
+				return false
+			}
+			p := info.pos
+			pe := p + info.size
+			for ; p < pe; p++ {
+				if s[bp] != rb.byte[p] {
+					return false
+				}
+				bp++
+			}
+		}
+		return true
+	})
+	for bp < len(s) {
+		if bp = decomposeSegment(&rb, bp, true); bp < 0 {
+			return false
+		}
+		bp, _ = rb.f.quickSpan(rb.src, bp, len(s), true)
+	}
+	return true
+}
+
+// patchTail fixes a case where a rune may be incorrectly normalized
+// if it is followed by illegal continuation bytes. It returns the
+// patched buffer and whether the decomposition is still in progress.
+func patchTail(rb *reorderBuffer) bool {
+	info, p := lastRuneStart(&rb.f, rb.out)
+	if p == -1 || info.size == 0 {
+		return true
+	}
+	end := p + int(info.size)
+	extra := len(rb.out) - end
+	if extra > 0 {
+		// Potentially allocating memory. However, this only
+		// happens with ill-formed UTF-8.
+		x := make([]byte, 0)
+		x = append(x, rb.out[len(rb.out)-extra:]...)
+		rb.out = rb.out[:end]
+		decomposeToLastBoundary(rb)
+		rb.doFlush()
+		rb.out = append(rb.out, x...)
+		return false
+	}
+	buf := rb.out[p:]
+	rb.out = rb.out[:p]
+	decomposeToLastBoundary(rb)
+	if s := rb.ss.next(info); s == ssStarter {
+		rb.doFlush()
+		rb.ss.first(info)
+	} else if s == ssOverflow {
+		rb.doFlush()
+		rb.insertCGJ()
+		rb.ss = 0
+	}
+	rb.insertUnsafe(inputBytes(buf), 0, info)
+	return true
+}
+
+func appendQuick(rb *reorderBuffer, i int) int {
+	if rb.nsrc == i {
+		return i
+	}
+	end, _ := rb.f.quickSpan(rb.src, i, rb.nsrc, true)
+	rb.out = rb.src.appendSlice(rb.out, i, end)
+	return end
+}
+
+// Append returns f(append(out, b...)).
+// The buffer out must be nil, empty, or equal to f(out).
+func (f Form) Append(out []byte, src ...byte) []byte {
+	return f.doAppend(out, inputBytes(src), len(src))
+}
+
+func (f Form) doAppend(out []byte, src input, n int) []byte {
+	if n == 0 {
+		return out
+	}
+	ft := formTable[f]
+	// Attempt to do a quickSpan first so we can avoid initializing the reorderBuffer.
+	if len(out) == 0 {
+		p, _ := ft.quickSpan(src, 0, n, true)
+		out = src.appendSlice(out, 0, p)
+		if p == n {
+			return out
+		}
+		rb := reorderBuffer{f: *ft, src: src, nsrc: n, out: out, flushF: appendFlush}
+		return doAppendInner(&rb, p)
+	}
+	rb := reorderBuffer{f: *ft, src: src, nsrc: n}
+	return doAppend(&rb, out, 0)
+}
+
+func doAppend(rb *reorderBuffer, out []byte, p int) []byte {
+	rb.setFlusher(out, appendFlush)
+	src, n := rb.src, rb.nsrc
+	doMerge := len(out) > 0
+	if q := src.skipContinuationBytes(p); q > p {
+		// Move leading non-starters to destination.
+		rb.out = src.appendSlice(rb.out, p, q)
+		p = q
+		doMerge = patchTail(rb)
+	}
+	fd := &rb.f
+	if doMerge {
+		var info Properties
+		if p < n {
+			info = fd.info(src, p)
+			if !info.BoundaryBefore() || info.nLeadingNonStarters() > 0 {
+				if p == 0 {
+					decomposeToLastBoundary(rb)
+				}
+				p = decomposeSegment(rb, p, true)
+			}
+		}
+		if info.size == 0 {
+			rb.doFlush()
+			// Append incomplete UTF-8 encoding.
+			return src.appendSlice(rb.out, p, n)
+		}
+		if rb.nrune > 0 {
+			return doAppendInner(rb, p)
+		}
+	}
+	p = appendQuick(rb, p)
+	return doAppendInner(rb, p)
+}
+
+func doAppendInner(rb *reorderBuffer, p int) []byte {
+	for n := rb.nsrc; p < n; {
+		p = decomposeSegment(rb, p, true)
+		p = appendQuick(rb, p)
+	}
+	return rb.out
+}
+
+// AppendString returns f(append(out, []byte(s))).
+// The buffer out must be nil, empty, or equal to f(out).
+func (f Form) AppendString(out []byte, src string) []byte {
+	return f.doAppend(out, inputString(src), len(src))
+}
+
+// QuickSpan returns a boundary n such that b[0:n] == f(b[0:n]).
+// It is not guaranteed to return the largest such n.
+func (f Form) QuickSpan(b []byte) int {
+	n, _ := formTable[f].quickSpan(inputBytes(b), 0, len(b), true)
+	return n
+}
+
+// Span implements transform.SpanningTransformer. It returns a boundary n such
+// that b[0:n] == f(b[0:n]). It is not guaranteed to return the largest such n.
+func (f Form) Span(b []byte, atEOF bool) (n int, err error) {
+	n, ok := formTable[f].quickSpan(inputBytes(b), 0, len(b), atEOF)
+	if n < len(b) {
+		if !ok {
+			err = transform.ErrEndOfSpan
+		} else {
+			err = transform.ErrShortSrc
+		}
+	}
+	return n, err
+}
+
+// SpanString returns a boundary n such that s[0:n] == f(s[0:n]).
+// It is not guaranteed to return the largest such n.
+func (f Form) SpanString(s string, atEOF bool) (n int, err error) {
+	n, ok := formTable[f].quickSpan(inputString(s), 0, len(s), atEOF)
+	if n < len(s) {
+		if !ok {
+			err = transform.ErrEndOfSpan
+		} else {
+			err = transform.ErrShortSrc
+		}
+	}
+	return n, err
+}
+
+// quickSpan returns a boundary n such that src[0:n] == f(src[0:n]) and
+// whether any non-normalized parts were found. If atEOF is false, n will
+// not point past the last segment if this segment might be become
+// non-normalized by appending other runes.
+func (f *formInfo) quickSpan(src input, i, end int, atEOF bool) (n int, ok bool) {
+	var lastCC uint8
+	ss := streamSafe(0)
+	lastSegStart := i
+	for n = end; i < n; {
+		if j := src.skipASCII(i, n); i != j {
+			i = j
+			lastSegStart = i - 1
+			lastCC = 0
+			ss = 0
+			continue
+		}
+		info := f.info(src, i)
+		if info.size == 0 {
+			if atEOF {
+				// include incomplete runes
+				return n, true
+			}
+			return lastSegStart, true
+		}
+		// This block needs to be before the next, because it is possible to
+		// have an overflow for runes that are starters (e.g. with U+FF9E).
+		switch ss.next(info) {
+		case ssStarter:
+			lastSegStart = i
+		case ssOverflow:
+			return lastSegStart, false
+		case ssSuccess:
+			if lastCC > info.ccc {
+				return lastSegStart, false
+			}
+		}
+		if f.composing {
+			if !info.isYesC() {
+				break
+			}
+		} else {
+			if !info.isYesD() {
+				break
+			}
+		}
+		lastCC = info.ccc
+		i += int(info.size)
+	}
+	if i == n {
+		if !atEOF {
+			n = lastSegStart
+		}
+		return n, true
+	}
+	return lastSegStart, false
+}
+
+// QuickSpanString returns a boundary n such that s[0:n] == f(s[0:n]).
+// It is not guaranteed to return the largest such n.
+func (f Form) QuickSpanString(s string) int {
+	n, _ := formTable[f].quickSpan(inputString(s), 0, len(s), true)
+	return n
+}
+
+// FirstBoundary returns the position i of the first boundary in b
+// or -1 if b contains no boundary.
+func (f Form) FirstBoundary(b []byte) int {
+	return f.firstBoundary(inputBytes(b), len(b))
+}
+
+func (f Form) firstBoundary(src input, nsrc int) int {
+	i := src.skipContinuationBytes(0)
+	if i >= nsrc {
+		return -1
+	}
+	fd := formTable[f]
+	ss := streamSafe(0)
+	// We should call ss.first here, but we can't as the first rune is
+	// skipped already. This means FirstBoundary can't really determine
+	// CGJ insertion points correctly. Luckily it doesn't have to.
+	for {
+		info := fd.info(src, i)
+		if info.size == 0 {
+			return -1
+		}
+		if s := ss.next(info); s != ssSuccess {
+			return i
+		}
+		i += int(info.size)
+		if i >= nsrc {
+			if !info.BoundaryAfter() && !ss.isMax() {
+				return -1
+			}
+			return nsrc
+		}
+	}
+}
+
+// FirstBoundaryInString returns the position i of the first boundary in s
+// or -1 if s contains no boundary.
+func (f Form) FirstBoundaryInString(s string) int {
+	return f.firstBoundary(inputString(s), len(s))
+}
+
+// NextBoundary reports the index of the boundary between the first and next
+// segment in b or -1 if atEOF is false and there are not enough bytes to
+// determine this boundary.
+func (f Form) NextBoundary(b []byte, atEOF bool) int {
+	return f.nextBoundary(inputBytes(b), len(b), atEOF)
+}
+
+// NextBoundaryInString reports the index of the boundary between the first and
+// next segment in b or -1 if atEOF is false and there are not enough bytes to
+// determine this boundary.
+func (f Form) NextBoundaryInString(s string, atEOF bool) int {
+	return f.nextBoundary(inputString(s), len(s), atEOF)
+}
+
+func (f Form) nextBoundary(src input, nsrc int, atEOF bool) int {
+	if nsrc == 0 {
+		if atEOF {
+			return 0
+		}
+		return -1
+	}
+	fd := formTable[f]
+	info := fd.info(src, 0)
+	if info.size == 0 {
+		if atEOF {
+			return 1
+		}
+		return -1
+	}
+	ss := streamSafe(0)
+	ss.first(info)
+
+	for i := int(info.size); i < nsrc; i += int(info.size) {
+		info = fd.info(src, i)
+		if info.size == 0 {
+			if atEOF {
+				return i
+			}
+			return -1
+		}
+		// TODO: Using streamSafe to determine the boundary isn't the same as
+		// using BoundaryBefore. Determine which should be used.
+		if s := ss.next(info); s != ssSuccess {
+			return i
+		}
+	}
+	if !atEOF && !info.BoundaryAfter() && !ss.isMax() {
+		return -1
+	}
+	return nsrc
+}
+
+// LastBoundary returns the position i of the last boundary in b
+// or -1 if b contains no boundary.
+func (f Form) LastBoundary(b []byte) int {
+	return lastBoundary(formTable[f], b)
+}
+
+func lastBoundary(fd *formInfo, b []byte) int {
+	i := len(b)
+	info, p := lastRuneStart(fd, b)
+	if p == -1 {
+		return -1
+	}
+	if info.size == 0 { // ends with incomplete rune
+		if p == 0 { // starts with incomplete rune
+			return -1
+		}
+		i = p
+		info, p = lastRuneStart(fd, b[:i])
+		if p == -1 { // incomplete UTF-8 encoding or non-starter bytes without a starter
+			return i
+		}
+	}
+	if p+int(info.size) != i { // trailing non-starter bytes: illegal UTF-8
+		return i
+	}
+	if info.BoundaryAfter() {
+		return i
+	}
+	ss := streamSafe(0)
+	v := ss.backwards(info)
+	for i = p; i >= 0 && v != ssStarter; i = p {
+		info, p = lastRuneStart(fd, b[:i])
+		if v = ss.backwards(info); v == ssOverflow {
+			break
+		}
+		if p+int(info.size) != i {
+			if p == -1 { // no boundary found
+				return -1
+			}
+			return i // boundary after an illegal UTF-8 encoding
+		}
+	}
+	return i
+}
+
+// decomposeSegment scans the first segment in src into rb. It inserts 0x034f
+// (Grapheme Joiner) when it encounters a sequence of more than 30 non-starters
+// and returns the number of bytes consumed from src or iShortDst or iShortSrc.
+func decomposeSegment(rb *reorderBuffer, sp int, atEOF bool) int {
+	// Force one character to be consumed.
+	info := rb.f.info(rb.src, sp)
+	if info.size == 0 {
+		return 0
+	}
+	if s := rb.ss.next(info); s == ssStarter {
+		// TODO: this could be removed if we don't support merging.
+		if rb.nrune > 0 {
+			goto end
+		}
+	} else if s == ssOverflow {
+		rb.insertCGJ()
+		goto end
+	}
+	if err := rb.insertFlush(rb.src, sp, info); err != iSuccess {
+		return int(err)
+	}
+	for {
+		sp += int(info.size)
+		if sp >= rb.nsrc {
+			if !atEOF && !info.BoundaryAfter() {
+				return int(iShortSrc)
+			}
+			break
+		}
+		info = rb.f.info(rb.src, sp)
+		if info.size == 0 {
+			if !atEOF {
+				return int(iShortSrc)
+			}
+			break
+		}
+		if s := rb.ss.next(info); s == ssStarter {
+			break
+		} else if s == ssOverflow {
+			rb.insertCGJ()
+			break
+		}
+		if err := rb.insertFlush(rb.src, sp, info); err != iSuccess {
+			return int(err)
+		}
+	}
+end:
+	if !rb.doFlush() {
+		return int(iShortDst)
+	}
+	return sp
+}
+
+// lastRuneStart returns the runeInfo and position of the last
+// rune in buf or the zero runeInfo and -1 if no rune was found.
+func lastRuneStart(fd *formInfo, buf []byte) (Properties, int) {
+	p := len(buf) - 1
+	for ; p >= 0 && !utf8.RuneStart(buf[p]); p-- {
+	}
+	if p < 0 {
+		return Properties{}, -1
+	}
+	return fd.info(inputBytes(buf), p), p
+}
+
+// decomposeToLastBoundary finds an open segment at the end of the buffer
+// and scans it into rb. Returns the buffer minus the last segment.
+func decomposeToLastBoundary(rb *reorderBuffer) {
+	fd := &rb.f
+	info, i := lastRuneStart(fd, rb.out)
+	if int(info.size) != len(rb.out)-i {
+		// illegal trailing continuation bytes
+		return
+	}
+	if info.BoundaryAfter() {
+		return
+	}
+	var add [maxNonStarters + 1]Properties // stores runeInfo in reverse order
+	padd := 0
+	ss := streamSafe(0)
+	p := len(rb.out)
+	for {
+		add[padd] = info
+		v := ss.backwards(info)
+		if v == ssOverflow {
+			// Note that if we have an overflow, it the string we are appending to
+			// is not correctly normalized. In this case the behavior is undefined.
+			break
+		}
+		padd++
+		p -= int(info.size)
+		if v == ssStarter || p < 0 {
+			break
+		}
+		info, i = lastRuneStart(fd, rb.out[:p])
+		if int(info.size) != p-i {
+			break
+		}
+	}
+	rb.ss = ss
+	// Copy bytes for insertion as we may need to overwrite rb.out.
+	var buf [maxBufferSize * utf8.UTFMax]byte
+	cp := buf[:copy(buf[:], rb.out[p:])]
+	rb.out = rb.out[:p]
+	for padd--; padd >= 0; padd-- {
+		info = add[padd]
+		rb.insertUnsafe(inputBytes(cp), 0, info)
+		cp = cp[info.size:]
+	}
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/readwriter.go b/vendor/golang.org/x/text/unicode/norm/readwriter.go
new file mode 100644
index 000000000..d926ee903
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/readwriter.go
@@ -0,0 +1,125 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+import "io"
+
+type normWriter struct {
+	rb  reorderBuffer
+	w   io.Writer
+	buf []byte
+}
+
+// Write implements the standard write interface.  If the last characters are
+// not at a normalization boundary, the bytes will be buffered for the next
+// write. The remaining bytes will be written on close.
+func (w *normWriter) Write(data []byte) (n int, err error) {
+	// Process data in pieces to keep w.buf size bounded.
+	const chunk = 4000
+
+	for len(data) > 0 {
+		// Normalize into w.buf.
+		m := len(data)
+		if m > chunk {
+			m = chunk
+		}
+		w.rb.src = inputBytes(data[:m])
+		w.rb.nsrc = m
+		w.buf = doAppend(&w.rb, w.buf, 0)
+		data = data[m:]
+		n += m
+
+		// Write out complete prefix, save remainder.
+		// Note that lastBoundary looks back at most 31 runes.
+		i := lastBoundary(&w.rb.f, w.buf)
+		if i == -1 {
+			i = 0
+		}
+		if i > 0 {
+			if _, err = w.w.Write(w.buf[:i]); err != nil {
+				break
+			}
+			bn := copy(w.buf, w.buf[i:])
+			w.buf = w.buf[:bn]
+		}
+	}
+	return n, err
+}
+
+// Close forces data that remains in the buffer to be written.
+func (w *normWriter) Close() error {
+	if len(w.buf) > 0 {
+		_, err := w.w.Write(w.buf)
+		if err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+// Writer returns a new writer that implements Write(b)
+// by writing f(b) to w.  The returned writer may use an
+// an internal buffer to maintain state across Write calls.
+// Calling its Close method writes any buffered data to w.
+func (f Form) Writer(w io.Writer) io.WriteCloser {
+	wr := &normWriter{rb: reorderBuffer{}, w: w}
+	wr.rb.init(f, nil)
+	return wr
+}
+
+type normReader struct {
+	rb           reorderBuffer
+	r            io.Reader
+	inbuf        []byte
+	outbuf       []byte
+	bufStart     int
+	lastBoundary int
+	err          error
+}
+
+// Read implements the standard read interface.
+func (r *normReader) Read(p []byte) (int, error) {
+	for {
+		if r.lastBoundary-r.bufStart > 0 {
+			n := copy(p, r.outbuf[r.bufStart:r.lastBoundary])
+			r.bufStart += n
+			if r.lastBoundary-r.bufStart > 0 {
+				return n, nil
+			}
+			return n, r.err
+		}
+		if r.err != nil {
+			return 0, r.err
+		}
+		outn := copy(r.outbuf, r.outbuf[r.lastBoundary:])
+		r.outbuf = r.outbuf[0:outn]
+		r.bufStart = 0
+
+		n, err := r.r.Read(r.inbuf)
+		r.rb.src = inputBytes(r.inbuf[0:n])
+		r.rb.nsrc, r.err = n, err
+		if n > 0 {
+			r.outbuf = doAppend(&r.rb, r.outbuf, 0)
+		}
+		if err == io.EOF {
+			r.lastBoundary = len(r.outbuf)
+		} else {
+			r.lastBoundary = lastBoundary(&r.rb.f, r.outbuf)
+			if r.lastBoundary == -1 {
+				r.lastBoundary = 0
+			}
+		}
+	}
+}
+
+// Reader returns a new reader that implements Read
+// by reading data from r and returning f(data).
+func (f Form) Reader(r io.Reader) io.Reader {
+	const chunk = 4000
+	buf := make([]byte, chunk)
+	rr := &normReader{rb: reorderBuffer{}, r: r, inbuf: buf}
+	rr.rb.init(f, buf)
+	return rr
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/tables.go b/vendor/golang.org/x/text/unicode/norm/tables.go
new file mode 100644
index 000000000..316b093c5
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/tables.go
@@ -0,0 +1,7651 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+package norm
+
+const (
+	// Version is the Unicode edition from which the tables are derived.
+	Version = "10.0.0"
+
+	// MaxTransformChunkSize indicates the maximum number of bytes that Transform
+	// may need to write atomically for any Form. Making a destination buffer at
+	// least this size ensures that Transform can always make progress and that
+	// the user does not need to grow the buffer on an ErrShortDst.
+	MaxTransformChunkSize = 35 + maxNonStarters*4
+)
+
+var ccc = [55]uint8{
+	0, 1, 7, 8, 9, 10, 11, 12,
+	13, 14, 15, 16, 17, 18, 19, 20,
+	21, 22, 23, 24, 25, 26, 27, 28,
+	29, 30, 31, 32, 33, 34, 35, 36,
+	84, 91, 103, 107, 118, 122, 129, 130,
+	132, 202, 214, 216, 218, 220, 222, 224,
+	226, 228, 230, 232, 233, 234, 240,
+}
+
+const (
+	firstMulti            = 0x186D
+	firstCCC              = 0x2C9E
+	endMulti              = 0x2F60
+	firstLeadingCCC       = 0x49AE
+	firstCCCZeroExcept    = 0x4A78
+	firstStarterWithNLead = 0x4A9F
+	lastDecomp            = 0x4AA1
+	maxDecomp             = 0x8000
+)
+
+// decomps: 19105 bytes
+var decomps = [...]byte{
+	// Bytes 0 - 3f
+	0x00, 0x41, 0x20, 0x41, 0x21, 0x41, 0x22, 0x41,
+	0x23, 0x41, 0x24, 0x41, 0x25, 0x41, 0x26, 0x41,
+	0x27, 0x41, 0x28, 0x41, 0x29, 0x41, 0x2A, 0x41,
+	0x2B, 0x41, 0x2C, 0x41, 0x2D, 0x41, 0x2E, 0x41,
+	0x2F, 0x41, 0x30, 0x41, 0x31, 0x41, 0x32, 0x41,
+	0x33, 0x41, 0x34, 0x41, 0x35, 0x41, 0x36, 0x41,
+	0x37, 0x41, 0x38, 0x41, 0x39, 0x41, 0x3A, 0x41,
+	0x3B, 0x41, 0x3C, 0x41, 0x3D, 0x41, 0x3E, 0x41,
+	// Bytes 40 - 7f
+	0x3F, 0x41, 0x40, 0x41, 0x41, 0x41, 0x42, 0x41,
+	0x43, 0x41, 0x44, 0x41, 0x45, 0x41, 0x46, 0x41,
+	0x47, 0x41, 0x48, 0x41, 0x49, 0x41, 0x4A, 0x41,
+	0x4B, 0x41, 0x4C, 0x41, 0x4D, 0x41, 0x4E, 0x41,
+	0x4F, 0x41, 0x50, 0x41, 0x51, 0x41, 0x52, 0x41,
+	0x53, 0x41, 0x54, 0x41, 0x55, 0x41, 0x56, 0x41,
+	0x57, 0x41, 0x58, 0x41, 0x59, 0x41, 0x5A, 0x41,
+	0x5B, 0x41, 0x5C, 0x41, 0x5D, 0x41, 0x5E, 0x41,
+	// Bytes 80 - bf
+	0x5F, 0x41, 0x60, 0x41, 0x61, 0x41, 0x62, 0x41,
+	0x63, 0x41, 0x64, 0x41, 0x65, 0x41, 0x66, 0x41,
+	0x67, 0x41, 0x68, 0x41, 0x69, 0x41, 0x6A, 0x41,
+	0x6B, 0x41, 0x6C, 0x41, 0x6D, 0x41, 0x6E, 0x41,
+	0x6F, 0x41, 0x70, 0x41, 0x71, 0x41, 0x72, 0x41,
+	0x73, 0x41, 0x74, 0x41, 0x75, 0x41, 0x76, 0x41,
+	0x77, 0x41, 0x78, 0x41, 0x79, 0x41, 0x7A, 0x41,
+	0x7B, 0x41, 0x7C, 0x41, 0x7D, 0x41, 0x7E, 0x42,
+	// Bytes c0 - ff
+	0xC2, 0xA2, 0x42, 0xC2, 0xA3, 0x42, 0xC2, 0xA5,
+	0x42, 0xC2, 0xA6, 0x42, 0xC2, 0xAC, 0x42, 0xC2,
+	0xB7, 0x42, 0xC3, 0x86, 0x42, 0xC3, 0xB0, 0x42,
+	0xC4, 0xA6, 0x42, 0xC4, 0xA7, 0x42, 0xC4, 0xB1,
+	0x42, 0xC5, 0x8B, 0x42, 0xC5, 0x93, 0x42, 0xC6,
+	0x8E, 0x42, 0xC6, 0x90, 0x42, 0xC6, 0xAB, 0x42,
+	0xC8, 0xA2, 0x42, 0xC8, 0xB7, 0x42, 0xC9, 0x90,
+	0x42, 0xC9, 0x91, 0x42, 0xC9, 0x92, 0x42, 0xC9,
+	// Bytes 100 - 13f
+	0x94, 0x42, 0xC9, 0x95, 0x42, 0xC9, 0x99, 0x42,
+	0xC9, 0x9B, 0x42, 0xC9, 0x9C, 0x42, 0xC9, 0x9F,
+	0x42, 0xC9, 0xA1, 0x42, 0xC9, 0xA3, 0x42, 0xC9,
+	0xA5, 0x42, 0xC9, 0xA6, 0x42, 0xC9, 0xA8, 0x42,
+	0xC9, 0xA9, 0x42, 0xC9, 0xAA, 0x42, 0xC9, 0xAB,
+	0x42, 0xC9, 0xAD, 0x42, 0xC9, 0xAF, 0x42, 0xC9,
+	0xB0, 0x42, 0xC9, 0xB1, 0x42, 0xC9, 0xB2, 0x42,
+	0xC9, 0xB3, 0x42, 0xC9, 0xB4, 0x42, 0xC9, 0xB5,
+	// Bytes 140 - 17f
+	0x42, 0xC9, 0xB8, 0x42, 0xC9, 0xB9, 0x42, 0xC9,
+	0xBB, 0x42, 0xCA, 0x81, 0x42, 0xCA, 0x82, 0x42,
+	0xCA, 0x83, 0x42, 0xCA, 0x89, 0x42, 0xCA, 0x8A,
+	0x42, 0xCA, 0x8B, 0x42, 0xCA, 0x8C, 0x42, 0xCA,
+	0x90, 0x42, 0xCA, 0x91, 0x42, 0xCA, 0x92, 0x42,
+	0xCA, 0x95, 0x42, 0xCA, 0x9D, 0x42, 0xCA, 0x9F,
+	0x42, 0xCA, 0xB9, 0x42, 0xCE, 0x91, 0x42, 0xCE,
+	0x92, 0x42, 0xCE, 0x93, 0x42, 0xCE, 0x94, 0x42,
+	// Bytes 180 - 1bf
+	0xCE, 0x95, 0x42, 0xCE, 0x96, 0x42, 0xCE, 0x97,
+	0x42, 0xCE, 0x98, 0x42, 0xCE, 0x99, 0x42, 0xCE,
+	0x9A, 0x42, 0xCE, 0x9B, 0x42, 0xCE, 0x9C, 0x42,
+	0xCE, 0x9D, 0x42, 0xCE, 0x9E, 0x42, 0xCE, 0x9F,
+	0x42, 0xCE, 0xA0, 0x42, 0xCE, 0xA1, 0x42, 0xCE,
+	0xA3, 0x42, 0xCE, 0xA4, 0x42, 0xCE, 0xA5, 0x42,
+	0xCE, 0xA6, 0x42, 0xCE, 0xA7, 0x42, 0xCE, 0xA8,
+	0x42, 0xCE, 0xA9, 0x42, 0xCE, 0xB1, 0x42, 0xCE,
+	// Bytes 1c0 - 1ff
+	0xB2, 0x42, 0xCE, 0xB3, 0x42, 0xCE, 0xB4, 0x42,
+	0xCE, 0xB5, 0x42, 0xCE, 0xB6, 0x42, 0xCE, 0xB7,
+	0x42, 0xCE, 0xB8, 0x42, 0xCE, 0xB9, 0x42, 0xCE,
+	0xBA, 0x42, 0xCE, 0xBB, 0x42, 0xCE, 0xBC, 0x42,
+	0xCE, 0xBD, 0x42, 0xCE, 0xBE, 0x42, 0xCE, 0xBF,
+	0x42, 0xCF, 0x80, 0x42, 0xCF, 0x81, 0x42, 0xCF,
+	0x82, 0x42, 0xCF, 0x83, 0x42, 0xCF, 0x84, 0x42,
+	0xCF, 0x85, 0x42, 0xCF, 0x86, 0x42, 0xCF, 0x87,
+	// Bytes 200 - 23f
+	0x42, 0xCF, 0x88, 0x42, 0xCF, 0x89, 0x42, 0xCF,
+	0x9C, 0x42, 0xCF, 0x9D, 0x42, 0xD0, 0xBD, 0x42,
+	0xD1, 0x8A, 0x42, 0xD1, 0x8C, 0x42, 0xD7, 0x90,
+	0x42, 0xD7, 0x91, 0x42, 0xD7, 0x92, 0x42, 0xD7,
+	0x93, 0x42, 0xD7, 0x94, 0x42, 0xD7, 0x9B, 0x42,
+	0xD7, 0x9C, 0x42, 0xD7, 0x9D, 0x42, 0xD7, 0xA2,
+	0x42, 0xD7, 0xA8, 0x42, 0xD7, 0xAA, 0x42, 0xD8,
+	0xA1, 0x42, 0xD8, 0xA7, 0x42, 0xD8, 0xA8, 0x42,
+	// Bytes 240 - 27f
+	0xD8, 0xA9, 0x42, 0xD8, 0xAA, 0x42, 0xD8, 0xAB,
+	0x42, 0xD8, 0xAC, 0x42, 0xD8, 0xAD, 0x42, 0xD8,
+	0xAE, 0x42, 0xD8, 0xAF, 0x42, 0xD8, 0xB0, 0x42,
+	0xD8, 0xB1, 0x42, 0xD8, 0xB2, 0x42, 0xD8, 0xB3,
+	0x42, 0xD8, 0xB4, 0x42, 0xD8, 0xB5, 0x42, 0xD8,
+	0xB6, 0x42, 0xD8, 0xB7, 0x42, 0xD8, 0xB8, 0x42,
+	0xD8, 0xB9, 0x42, 0xD8, 0xBA, 0x42, 0xD9, 0x81,
+	0x42, 0xD9, 0x82, 0x42, 0xD9, 0x83, 0x42, 0xD9,
+	// Bytes 280 - 2bf
+	0x84, 0x42, 0xD9, 0x85, 0x42, 0xD9, 0x86, 0x42,
+	0xD9, 0x87, 0x42, 0xD9, 0x88, 0x42, 0xD9, 0x89,
+	0x42, 0xD9, 0x8A, 0x42, 0xD9, 0xAE, 0x42, 0xD9,
+	0xAF, 0x42, 0xD9, 0xB1, 0x42, 0xD9, 0xB9, 0x42,
+	0xD9, 0xBA, 0x42, 0xD9, 0xBB, 0x42, 0xD9, 0xBE,
+	0x42, 0xD9, 0xBF, 0x42, 0xDA, 0x80, 0x42, 0xDA,
+	0x83, 0x42, 0xDA, 0x84, 0x42, 0xDA, 0x86, 0x42,
+	0xDA, 0x87, 0x42, 0xDA, 0x88, 0x42, 0xDA, 0x8C,
+	// Bytes 2c0 - 2ff
+	0x42, 0xDA, 0x8D, 0x42, 0xDA, 0x8E, 0x42, 0xDA,
+	0x91, 0x42, 0xDA, 0x98, 0x42, 0xDA, 0xA1, 0x42,
+	0xDA, 0xA4, 0x42, 0xDA, 0xA6, 0x42, 0xDA, 0xA9,
+	0x42, 0xDA, 0xAD, 0x42, 0xDA, 0xAF, 0x42, 0xDA,
+	0xB1, 0x42, 0xDA, 0xB3, 0x42, 0xDA, 0xBA, 0x42,
+	0xDA, 0xBB, 0x42, 0xDA, 0xBE, 0x42, 0xDB, 0x81,
+	0x42, 0xDB, 0x85, 0x42, 0xDB, 0x86, 0x42, 0xDB,
+	0x87, 0x42, 0xDB, 0x88, 0x42, 0xDB, 0x89, 0x42,
+	// Bytes 300 - 33f
+	0xDB, 0x8B, 0x42, 0xDB, 0x8C, 0x42, 0xDB, 0x90,
+	0x42, 0xDB, 0x92, 0x43, 0xE0, 0xBC, 0x8B, 0x43,
+	0xE1, 0x83, 0x9C, 0x43, 0xE1, 0x84, 0x80, 0x43,
+	0xE1, 0x84, 0x81, 0x43, 0xE1, 0x84, 0x82, 0x43,
+	0xE1, 0x84, 0x83, 0x43, 0xE1, 0x84, 0x84, 0x43,
+	0xE1, 0x84, 0x85, 0x43, 0xE1, 0x84, 0x86, 0x43,
+	0xE1, 0x84, 0x87, 0x43, 0xE1, 0x84, 0x88, 0x43,
+	0xE1, 0x84, 0x89, 0x43, 0xE1, 0x84, 0x8A, 0x43,
+	// Bytes 340 - 37f
+	0xE1, 0x84, 0x8B, 0x43, 0xE1, 0x84, 0x8C, 0x43,
+	0xE1, 0x84, 0x8D, 0x43, 0xE1, 0x84, 0x8E, 0x43,
+	0xE1, 0x84, 0x8F, 0x43, 0xE1, 0x84, 0x90, 0x43,
+	0xE1, 0x84, 0x91, 0x43, 0xE1, 0x84, 0x92, 0x43,
+	0xE1, 0x84, 0x94, 0x43, 0xE1, 0x84, 0x95, 0x43,
+	0xE1, 0x84, 0x9A, 0x43, 0xE1, 0x84, 0x9C, 0x43,
+	0xE1, 0x84, 0x9D, 0x43, 0xE1, 0x84, 0x9E, 0x43,
+	0xE1, 0x84, 0xA0, 0x43, 0xE1, 0x84, 0xA1, 0x43,
+	// Bytes 380 - 3bf
+	0xE1, 0x84, 0xA2, 0x43, 0xE1, 0x84, 0xA3, 0x43,
+	0xE1, 0x84, 0xA7, 0x43, 0xE1, 0x84, 0xA9, 0x43,
+	0xE1, 0x84, 0xAB, 0x43, 0xE1, 0x84, 0xAC, 0x43,
+	0xE1, 0x84, 0xAD, 0x43, 0xE1, 0x84, 0xAE, 0x43,
+	0xE1, 0x84, 0xAF, 0x43, 0xE1, 0x84, 0xB2, 0x43,
+	0xE1, 0x84, 0xB6, 0x43, 0xE1, 0x85, 0x80, 0x43,
+	0xE1, 0x85, 0x87, 0x43, 0xE1, 0x85, 0x8C, 0x43,
+	0xE1, 0x85, 0x97, 0x43, 0xE1, 0x85, 0x98, 0x43,
+	// Bytes 3c0 - 3ff
+	0xE1, 0x85, 0x99, 0x43, 0xE1, 0x85, 0xA0, 0x43,
+	0xE1, 0x86, 0x84, 0x43, 0xE1, 0x86, 0x85, 0x43,
+	0xE1, 0x86, 0x88, 0x43, 0xE1, 0x86, 0x91, 0x43,
+	0xE1, 0x86, 0x92, 0x43, 0xE1, 0x86, 0x94, 0x43,
+	0xE1, 0x86, 0x9E, 0x43, 0xE1, 0x86, 0xA1, 0x43,
+	0xE1, 0x87, 0x87, 0x43, 0xE1, 0x87, 0x88, 0x43,
+	0xE1, 0x87, 0x8C, 0x43, 0xE1, 0x87, 0x8E, 0x43,
+	0xE1, 0x87, 0x93, 0x43, 0xE1, 0x87, 0x97, 0x43,
+	// Bytes 400 - 43f
+	0xE1, 0x87, 0x99, 0x43, 0xE1, 0x87, 0x9D, 0x43,
+	0xE1, 0x87, 0x9F, 0x43, 0xE1, 0x87, 0xB1, 0x43,
+	0xE1, 0x87, 0xB2, 0x43, 0xE1, 0xB4, 0x82, 0x43,
+	0xE1, 0xB4, 0x96, 0x43, 0xE1, 0xB4, 0x97, 0x43,
+	0xE1, 0xB4, 0x9C, 0x43, 0xE1, 0xB4, 0x9D, 0x43,
+	0xE1, 0xB4, 0xA5, 0x43, 0xE1, 0xB5, 0xBB, 0x43,
+	0xE1, 0xB6, 0x85, 0x43, 0xE2, 0x80, 0x82, 0x43,
+	0xE2, 0x80, 0x83, 0x43, 0xE2, 0x80, 0x90, 0x43,
+	// Bytes 440 - 47f
+	0xE2, 0x80, 0x93, 0x43, 0xE2, 0x80, 0x94, 0x43,
+	0xE2, 0x82, 0xA9, 0x43, 0xE2, 0x86, 0x90, 0x43,
+	0xE2, 0x86, 0x91, 0x43, 0xE2, 0x86, 0x92, 0x43,
+	0xE2, 0x86, 0x93, 0x43, 0xE2, 0x88, 0x82, 0x43,
+	0xE2, 0x88, 0x87, 0x43, 0xE2, 0x88, 0x91, 0x43,
+	0xE2, 0x88, 0x92, 0x43, 0xE2, 0x94, 0x82, 0x43,
+	0xE2, 0x96, 0xA0, 0x43, 0xE2, 0x97, 0x8B, 0x43,
+	0xE2, 0xA6, 0x85, 0x43, 0xE2, 0xA6, 0x86, 0x43,
+	// Bytes 480 - 4bf
+	0xE2, 0xB5, 0xA1, 0x43, 0xE3, 0x80, 0x81, 0x43,
+	0xE3, 0x80, 0x82, 0x43, 0xE3, 0x80, 0x88, 0x43,
+	0xE3, 0x80, 0x89, 0x43, 0xE3, 0x80, 0x8A, 0x43,
+	0xE3, 0x80, 0x8B, 0x43, 0xE3, 0x80, 0x8C, 0x43,
+	0xE3, 0x80, 0x8D, 0x43, 0xE3, 0x80, 0x8E, 0x43,
+	0xE3, 0x80, 0x8F, 0x43, 0xE3, 0x80, 0x90, 0x43,
+	0xE3, 0x80, 0x91, 0x43, 0xE3, 0x80, 0x92, 0x43,
+	0xE3, 0x80, 0x94, 0x43, 0xE3, 0x80, 0x95, 0x43,
+	// Bytes 4c0 - 4ff
+	0xE3, 0x80, 0x96, 0x43, 0xE3, 0x80, 0x97, 0x43,
+	0xE3, 0x82, 0xA1, 0x43, 0xE3, 0x82, 0xA2, 0x43,
+	0xE3, 0x82, 0xA3, 0x43, 0xE3, 0x82, 0xA4, 0x43,
+	0xE3, 0x82, 0xA5, 0x43, 0xE3, 0x82, 0xA6, 0x43,
+	0xE3, 0x82, 0xA7, 0x43, 0xE3, 0x82, 0xA8, 0x43,
+	0xE3, 0x82, 0xA9, 0x43, 0xE3, 0x82, 0xAA, 0x43,
+	0xE3, 0x82, 0xAB, 0x43, 0xE3, 0x82, 0xAD, 0x43,
+	0xE3, 0x82, 0xAF, 0x43, 0xE3, 0x82, 0xB1, 0x43,
+	// Bytes 500 - 53f
+	0xE3, 0x82, 0xB3, 0x43, 0xE3, 0x82, 0xB5, 0x43,
+	0xE3, 0x82, 0xB7, 0x43, 0xE3, 0x82, 0xB9, 0x43,
+	0xE3, 0x82, 0xBB, 0x43, 0xE3, 0x82, 0xBD, 0x43,
+	0xE3, 0x82, 0xBF, 0x43, 0xE3, 0x83, 0x81, 0x43,
+	0xE3, 0x83, 0x83, 0x43, 0xE3, 0x83, 0x84, 0x43,
+	0xE3, 0x83, 0x86, 0x43, 0xE3, 0x83, 0x88, 0x43,
+	0xE3, 0x83, 0x8A, 0x43, 0xE3, 0x83, 0x8B, 0x43,
+	0xE3, 0x83, 0x8C, 0x43, 0xE3, 0x83, 0x8D, 0x43,
+	// Bytes 540 - 57f
+	0xE3, 0x83, 0x8E, 0x43, 0xE3, 0x83, 0x8F, 0x43,
+	0xE3, 0x83, 0x92, 0x43, 0xE3, 0x83, 0x95, 0x43,
+	0xE3, 0x83, 0x98, 0x43, 0xE3, 0x83, 0x9B, 0x43,
+	0xE3, 0x83, 0x9E, 0x43, 0xE3, 0x83, 0x9F, 0x43,
+	0xE3, 0x83, 0xA0, 0x43, 0xE3, 0x83, 0xA1, 0x43,
+	0xE3, 0x83, 0xA2, 0x43, 0xE3, 0x83, 0xA3, 0x43,
+	0xE3, 0x83, 0xA4, 0x43, 0xE3, 0x83, 0xA5, 0x43,
+	0xE3, 0x83, 0xA6, 0x43, 0xE3, 0x83, 0xA7, 0x43,
+	// Bytes 580 - 5bf
+	0xE3, 0x83, 0xA8, 0x43, 0xE3, 0x83, 0xA9, 0x43,
+	0xE3, 0x83, 0xAA, 0x43, 0xE3, 0x83, 0xAB, 0x43,
+	0xE3, 0x83, 0xAC, 0x43, 0xE3, 0x83, 0xAD, 0x43,
+	0xE3, 0x83, 0xAF, 0x43, 0xE3, 0x83, 0xB0, 0x43,
+	0xE3, 0x83, 0xB1, 0x43, 0xE3, 0x83, 0xB2, 0x43,
+	0xE3, 0x83, 0xB3, 0x43, 0xE3, 0x83, 0xBB, 0x43,
+	0xE3, 0x83, 0xBC, 0x43, 0xE3, 0x92, 0x9E, 0x43,
+	0xE3, 0x92, 0xB9, 0x43, 0xE3, 0x92, 0xBB, 0x43,
+	// Bytes 5c0 - 5ff
+	0xE3, 0x93, 0x9F, 0x43, 0xE3, 0x94, 0x95, 0x43,
+	0xE3, 0x9B, 0xAE, 0x43, 0xE3, 0x9B, 0xBC, 0x43,
+	0xE3, 0x9E, 0x81, 0x43, 0xE3, 0xA0, 0xAF, 0x43,
+	0xE3, 0xA1, 0xA2, 0x43, 0xE3, 0xA1, 0xBC, 0x43,
+	0xE3, 0xA3, 0x87, 0x43, 0xE3, 0xA3, 0xA3, 0x43,
+	0xE3, 0xA4, 0x9C, 0x43, 0xE3, 0xA4, 0xBA, 0x43,
+	0xE3, 0xA8, 0xAE, 0x43, 0xE3, 0xA9, 0xAC, 0x43,
+	0xE3, 0xAB, 0xA4, 0x43, 0xE3, 0xAC, 0x88, 0x43,
+	// Bytes 600 - 63f
+	0xE3, 0xAC, 0x99, 0x43, 0xE3, 0xAD, 0x89, 0x43,
+	0xE3, 0xAE, 0x9D, 0x43, 0xE3, 0xB0, 0x98, 0x43,
+	0xE3, 0xB1, 0x8E, 0x43, 0xE3, 0xB4, 0xB3, 0x43,
+	0xE3, 0xB6, 0x96, 0x43, 0xE3, 0xBA, 0xAC, 0x43,
+	0xE3, 0xBA, 0xB8, 0x43, 0xE3, 0xBC, 0x9B, 0x43,
+	0xE3, 0xBF, 0xBC, 0x43, 0xE4, 0x80, 0x88, 0x43,
+	0xE4, 0x80, 0x98, 0x43, 0xE4, 0x80, 0xB9, 0x43,
+	0xE4, 0x81, 0x86, 0x43, 0xE4, 0x82, 0x96, 0x43,
+	// Bytes 640 - 67f
+	0xE4, 0x83, 0xA3, 0x43, 0xE4, 0x84, 0xAF, 0x43,
+	0xE4, 0x88, 0x82, 0x43, 0xE4, 0x88, 0xA7, 0x43,
+	0xE4, 0x8A, 0xA0, 0x43, 0xE4, 0x8C, 0x81, 0x43,
+	0xE4, 0x8C, 0xB4, 0x43, 0xE4, 0x8D, 0x99, 0x43,
+	0xE4, 0x8F, 0x95, 0x43, 0xE4, 0x8F, 0x99, 0x43,
+	0xE4, 0x90, 0x8B, 0x43, 0xE4, 0x91, 0xAB, 0x43,
+	0xE4, 0x94, 0xAB, 0x43, 0xE4, 0x95, 0x9D, 0x43,
+	0xE4, 0x95, 0xA1, 0x43, 0xE4, 0x95, 0xAB, 0x43,
+	// Bytes 680 - 6bf
+	0xE4, 0x97, 0x97, 0x43, 0xE4, 0x97, 0xB9, 0x43,
+	0xE4, 0x98, 0xB5, 0x43, 0xE4, 0x9A, 0xBE, 0x43,
+	0xE4, 0x9B, 0x87, 0x43, 0xE4, 0xA6, 0x95, 0x43,
+	0xE4, 0xA7, 0xA6, 0x43, 0xE4, 0xA9, 0xAE, 0x43,
+	0xE4, 0xA9, 0xB6, 0x43, 0xE4, 0xAA, 0xB2, 0x43,
+	0xE4, 0xAC, 0xB3, 0x43, 0xE4, 0xAF, 0x8E, 0x43,
+	0xE4, 0xB3, 0x8E, 0x43, 0xE4, 0xB3, 0xAD, 0x43,
+	0xE4, 0xB3, 0xB8, 0x43, 0xE4, 0xB5, 0x96, 0x43,
+	// Bytes 6c0 - 6ff
+	0xE4, 0xB8, 0x80, 0x43, 0xE4, 0xB8, 0x81, 0x43,
+	0xE4, 0xB8, 0x83, 0x43, 0xE4, 0xB8, 0x89, 0x43,
+	0xE4, 0xB8, 0x8A, 0x43, 0xE4, 0xB8, 0x8B, 0x43,
+	0xE4, 0xB8, 0x8D, 0x43, 0xE4, 0xB8, 0x99, 0x43,
+	0xE4, 0xB8, 0xA6, 0x43, 0xE4, 0xB8, 0xA8, 0x43,
+	0xE4, 0xB8, 0xAD, 0x43, 0xE4, 0xB8, 0xB2, 0x43,
+	0xE4, 0xB8, 0xB6, 0x43, 0xE4, 0xB8, 0xB8, 0x43,
+	0xE4, 0xB8, 0xB9, 0x43, 0xE4, 0xB8, 0xBD, 0x43,
+	// Bytes 700 - 73f
+	0xE4, 0xB8, 0xBF, 0x43, 0xE4, 0xB9, 0x81, 0x43,
+	0xE4, 0xB9, 0x99, 0x43, 0xE4, 0xB9, 0x9D, 0x43,
+	0xE4, 0xBA, 0x82, 0x43, 0xE4, 0xBA, 0x85, 0x43,
+	0xE4, 0xBA, 0x86, 0x43, 0xE4, 0xBA, 0x8C, 0x43,
+	0xE4, 0xBA, 0x94, 0x43, 0xE4, 0xBA, 0xA0, 0x43,
+	0xE4, 0xBA, 0xA4, 0x43, 0xE4, 0xBA, 0xAE, 0x43,
+	0xE4, 0xBA, 0xBA, 0x43, 0xE4, 0xBB, 0x80, 0x43,
+	0xE4, 0xBB, 0x8C, 0x43, 0xE4, 0xBB, 0xA4, 0x43,
+	// Bytes 740 - 77f
+	0xE4, 0xBC, 0x81, 0x43, 0xE4, 0xBC, 0x91, 0x43,
+	0xE4, 0xBD, 0xA0, 0x43, 0xE4, 0xBE, 0x80, 0x43,
+	0xE4, 0xBE, 0x86, 0x43, 0xE4, 0xBE, 0x8B, 0x43,
+	0xE4, 0xBE, 0xAE, 0x43, 0xE4, 0xBE, 0xBB, 0x43,
+	0xE4, 0xBE, 0xBF, 0x43, 0xE5, 0x80, 0x82, 0x43,
+	0xE5, 0x80, 0xAB, 0x43, 0xE5, 0x81, 0xBA, 0x43,
+	0xE5, 0x82, 0x99, 0x43, 0xE5, 0x83, 0x8F, 0x43,
+	0xE5, 0x83, 0x9A, 0x43, 0xE5, 0x83, 0xA7, 0x43,
+	// Bytes 780 - 7bf
+	0xE5, 0x84, 0xAA, 0x43, 0xE5, 0x84, 0xBF, 0x43,
+	0xE5, 0x85, 0x80, 0x43, 0xE5, 0x85, 0x85, 0x43,
+	0xE5, 0x85, 0x8D, 0x43, 0xE5, 0x85, 0x94, 0x43,
+	0xE5, 0x85, 0xA4, 0x43, 0xE5, 0x85, 0xA5, 0x43,
+	0xE5, 0x85, 0xA7, 0x43, 0xE5, 0x85, 0xA8, 0x43,
+	0xE5, 0x85, 0xA9, 0x43, 0xE5, 0x85, 0xAB, 0x43,
+	0xE5, 0x85, 0xAD, 0x43, 0xE5, 0x85, 0xB7, 0x43,
+	0xE5, 0x86, 0x80, 0x43, 0xE5, 0x86, 0x82, 0x43,
+	// Bytes 7c0 - 7ff
+	0xE5, 0x86, 0x8D, 0x43, 0xE5, 0x86, 0x92, 0x43,
+	0xE5, 0x86, 0x95, 0x43, 0xE5, 0x86, 0x96, 0x43,
+	0xE5, 0x86, 0x97, 0x43, 0xE5, 0x86, 0x99, 0x43,
+	0xE5, 0x86, 0xA4, 0x43, 0xE5, 0x86, 0xAB, 0x43,
+	0xE5, 0x86, 0xAC, 0x43, 0xE5, 0x86, 0xB5, 0x43,
+	0xE5, 0x86, 0xB7, 0x43, 0xE5, 0x87, 0x89, 0x43,
+	0xE5, 0x87, 0x8C, 0x43, 0xE5, 0x87, 0x9C, 0x43,
+	0xE5, 0x87, 0x9E, 0x43, 0xE5, 0x87, 0xA0, 0x43,
+	// Bytes 800 - 83f
+	0xE5, 0x87, 0xB5, 0x43, 0xE5, 0x88, 0x80, 0x43,
+	0xE5, 0x88, 0x83, 0x43, 0xE5, 0x88, 0x87, 0x43,
+	0xE5, 0x88, 0x97, 0x43, 0xE5, 0x88, 0x9D, 0x43,
+	0xE5, 0x88, 0xA9, 0x43, 0xE5, 0x88, 0xBA, 0x43,
+	0xE5, 0x88, 0xBB, 0x43, 0xE5, 0x89, 0x86, 0x43,
+	0xE5, 0x89, 0x8D, 0x43, 0xE5, 0x89, 0xB2, 0x43,
+	0xE5, 0x89, 0xB7, 0x43, 0xE5, 0x8A, 0x89, 0x43,
+	0xE5, 0x8A, 0x9B, 0x43, 0xE5, 0x8A, 0xA3, 0x43,
+	// Bytes 840 - 87f
+	0xE5, 0x8A, 0xB3, 0x43, 0xE5, 0x8A, 0xB4, 0x43,
+	0xE5, 0x8B, 0x87, 0x43, 0xE5, 0x8B, 0x89, 0x43,
+	0xE5, 0x8B, 0x92, 0x43, 0xE5, 0x8B, 0x9E, 0x43,
+	0xE5, 0x8B, 0xA4, 0x43, 0xE5, 0x8B, 0xB5, 0x43,
+	0xE5, 0x8B, 0xB9, 0x43, 0xE5, 0x8B, 0xBA, 0x43,
+	0xE5, 0x8C, 0x85, 0x43, 0xE5, 0x8C, 0x86, 0x43,
+	0xE5, 0x8C, 0x95, 0x43, 0xE5, 0x8C, 0x97, 0x43,
+	0xE5, 0x8C, 0x9A, 0x43, 0xE5, 0x8C, 0xB8, 0x43,
+	// Bytes 880 - 8bf
+	0xE5, 0x8C, 0xBB, 0x43, 0xE5, 0x8C, 0xBF, 0x43,
+	0xE5, 0x8D, 0x81, 0x43, 0xE5, 0x8D, 0x84, 0x43,
+	0xE5, 0x8D, 0x85, 0x43, 0xE5, 0x8D, 0x89, 0x43,
+	0xE5, 0x8D, 0x91, 0x43, 0xE5, 0x8D, 0x94, 0x43,
+	0xE5, 0x8D, 0x9A, 0x43, 0xE5, 0x8D, 0x9C, 0x43,
+	0xE5, 0x8D, 0xA9, 0x43, 0xE5, 0x8D, 0xB0, 0x43,
+	0xE5, 0x8D, 0xB3, 0x43, 0xE5, 0x8D, 0xB5, 0x43,
+	0xE5, 0x8D, 0xBD, 0x43, 0xE5, 0x8D, 0xBF, 0x43,
+	// Bytes 8c0 - 8ff
+	0xE5, 0x8E, 0x82, 0x43, 0xE5, 0x8E, 0xB6, 0x43,
+	0xE5, 0x8F, 0x83, 0x43, 0xE5, 0x8F, 0x88, 0x43,
+	0xE5, 0x8F, 0x8A, 0x43, 0xE5, 0x8F, 0x8C, 0x43,
+	0xE5, 0x8F, 0x9F, 0x43, 0xE5, 0x8F, 0xA3, 0x43,
+	0xE5, 0x8F, 0xA5, 0x43, 0xE5, 0x8F, 0xAB, 0x43,
+	0xE5, 0x8F, 0xAF, 0x43, 0xE5, 0x8F, 0xB1, 0x43,
+	0xE5, 0x8F, 0xB3, 0x43, 0xE5, 0x90, 0x86, 0x43,
+	0xE5, 0x90, 0x88, 0x43, 0xE5, 0x90, 0x8D, 0x43,
+	// Bytes 900 - 93f
+	0xE5, 0x90, 0x8F, 0x43, 0xE5, 0x90, 0x9D, 0x43,
+	0xE5, 0x90, 0xB8, 0x43, 0xE5, 0x90, 0xB9, 0x43,
+	0xE5, 0x91, 0x82, 0x43, 0xE5, 0x91, 0x88, 0x43,
+	0xE5, 0x91, 0xA8, 0x43, 0xE5, 0x92, 0x9E, 0x43,
+	0xE5, 0x92, 0xA2, 0x43, 0xE5, 0x92, 0xBD, 0x43,
+	0xE5, 0x93, 0xB6, 0x43, 0xE5, 0x94, 0x90, 0x43,
+	0xE5, 0x95, 0x8F, 0x43, 0xE5, 0x95, 0x93, 0x43,
+	0xE5, 0x95, 0x95, 0x43, 0xE5, 0x95, 0xA3, 0x43,
+	// Bytes 940 - 97f
+	0xE5, 0x96, 0x84, 0x43, 0xE5, 0x96, 0x87, 0x43,
+	0xE5, 0x96, 0x99, 0x43, 0xE5, 0x96, 0x9D, 0x43,
+	0xE5, 0x96, 0xAB, 0x43, 0xE5, 0x96, 0xB3, 0x43,
+	0xE5, 0x96, 0xB6, 0x43, 0xE5, 0x97, 0x80, 0x43,
+	0xE5, 0x97, 0x82, 0x43, 0xE5, 0x97, 0xA2, 0x43,
+	0xE5, 0x98, 0x86, 0x43, 0xE5, 0x99, 0x91, 0x43,
+	0xE5, 0x99, 0xA8, 0x43, 0xE5, 0x99, 0xB4, 0x43,
+	0xE5, 0x9B, 0x97, 0x43, 0xE5, 0x9B, 0x9B, 0x43,
+	// Bytes 980 - 9bf
+	0xE5, 0x9B, 0xB9, 0x43, 0xE5, 0x9C, 0x96, 0x43,
+	0xE5, 0x9C, 0x97, 0x43, 0xE5, 0x9C, 0x9F, 0x43,
+	0xE5, 0x9C, 0xB0, 0x43, 0xE5, 0x9E, 0x8B, 0x43,
+	0xE5, 0x9F, 0x8E, 0x43, 0xE5, 0x9F, 0xB4, 0x43,
+	0xE5, 0xA0, 0x8D, 0x43, 0xE5, 0xA0, 0xB1, 0x43,
+	0xE5, 0xA0, 0xB2, 0x43, 0xE5, 0xA1, 0x80, 0x43,
+	0xE5, 0xA1, 0x9A, 0x43, 0xE5, 0xA1, 0x9E, 0x43,
+	0xE5, 0xA2, 0xA8, 0x43, 0xE5, 0xA2, 0xAC, 0x43,
+	// Bytes 9c0 - 9ff
+	0xE5, 0xA2, 0xB3, 0x43, 0xE5, 0xA3, 0x98, 0x43,
+	0xE5, 0xA3, 0x9F, 0x43, 0xE5, 0xA3, 0xAB, 0x43,
+	0xE5, 0xA3, 0xAE, 0x43, 0xE5, 0xA3, 0xB0, 0x43,
+	0xE5, 0xA3, 0xB2, 0x43, 0xE5, 0xA3, 0xB7, 0x43,
+	0xE5, 0xA4, 0x82, 0x43, 0xE5, 0xA4, 0x86, 0x43,
+	0xE5, 0xA4, 0x8A, 0x43, 0xE5, 0xA4, 0x95, 0x43,
+	0xE5, 0xA4, 0x9A, 0x43, 0xE5, 0xA4, 0x9C, 0x43,
+	0xE5, 0xA4, 0xA2, 0x43, 0xE5, 0xA4, 0xA7, 0x43,
+	// Bytes a00 - a3f
+	0xE5, 0xA4, 0xA9, 0x43, 0xE5, 0xA5, 0x84, 0x43,
+	0xE5, 0xA5, 0x88, 0x43, 0xE5, 0xA5, 0x91, 0x43,
+	0xE5, 0xA5, 0x94, 0x43, 0xE5, 0xA5, 0xA2, 0x43,
+	0xE5, 0xA5, 0xB3, 0x43, 0xE5, 0xA7, 0x98, 0x43,
+	0xE5, 0xA7, 0xAC, 0x43, 0xE5, 0xA8, 0x9B, 0x43,
+	0xE5, 0xA8, 0xA7, 0x43, 0xE5, 0xA9, 0xA2, 0x43,
+	0xE5, 0xA9, 0xA6, 0x43, 0xE5, 0xAA, 0xB5, 0x43,
+	0xE5, 0xAC, 0x88, 0x43, 0xE5, 0xAC, 0xA8, 0x43,
+	// Bytes a40 - a7f
+	0xE5, 0xAC, 0xBE, 0x43, 0xE5, 0xAD, 0x90, 0x43,
+	0xE5, 0xAD, 0x97, 0x43, 0xE5, 0xAD, 0xA6, 0x43,
+	0xE5, 0xAE, 0x80, 0x43, 0xE5, 0xAE, 0x85, 0x43,
+	0xE5, 0xAE, 0x97, 0x43, 0xE5, 0xAF, 0x83, 0x43,
+	0xE5, 0xAF, 0x98, 0x43, 0xE5, 0xAF, 0xA7, 0x43,
+	0xE5, 0xAF, 0xAE, 0x43, 0xE5, 0xAF, 0xB3, 0x43,
+	0xE5, 0xAF, 0xB8, 0x43, 0xE5, 0xAF, 0xBF, 0x43,
+	0xE5, 0xB0, 0x86, 0x43, 0xE5, 0xB0, 0x8F, 0x43,
+	// Bytes a80 - abf
+	0xE5, 0xB0, 0xA2, 0x43, 0xE5, 0xB0, 0xB8, 0x43,
+	0xE5, 0xB0, 0xBF, 0x43, 0xE5, 0xB1, 0xA0, 0x43,
+	0xE5, 0xB1, 0xA2, 0x43, 0xE5, 0xB1, 0xA4, 0x43,
+	0xE5, 0xB1, 0xA5, 0x43, 0xE5, 0xB1, 0xAE, 0x43,
+	0xE5, 0xB1, 0xB1, 0x43, 0xE5, 0xB2, 0x8D, 0x43,
+	0xE5, 0xB3, 0x80, 0x43, 0xE5, 0xB4, 0x99, 0x43,
+	0xE5, 0xB5, 0x83, 0x43, 0xE5, 0xB5, 0x90, 0x43,
+	0xE5, 0xB5, 0xAB, 0x43, 0xE5, 0xB5, 0xAE, 0x43,
+	// Bytes ac0 - aff
+	0xE5, 0xB5, 0xBC, 0x43, 0xE5, 0xB6, 0xB2, 0x43,
+	0xE5, 0xB6, 0xBA, 0x43, 0xE5, 0xB7, 0x9B, 0x43,
+	0xE5, 0xB7, 0xA1, 0x43, 0xE5, 0xB7, 0xA2, 0x43,
+	0xE5, 0xB7, 0xA5, 0x43, 0xE5, 0xB7, 0xA6, 0x43,
+	0xE5, 0xB7, 0xB1, 0x43, 0xE5, 0xB7, 0xBD, 0x43,
+	0xE5, 0xB7, 0xBE, 0x43, 0xE5, 0xB8, 0xA8, 0x43,
+	0xE5, 0xB8, 0xBD, 0x43, 0xE5, 0xB9, 0xA9, 0x43,
+	0xE5, 0xB9, 0xB2, 0x43, 0xE5, 0xB9, 0xB4, 0x43,
+	// Bytes b00 - b3f
+	0xE5, 0xB9, 0xBA, 0x43, 0xE5, 0xB9, 0xBC, 0x43,
+	0xE5, 0xB9, 0xBF, 0x43, 0xE5, 0xBA, 0xA6, 0x43,
+	0xE5, 0xBA, 0xB0, 0x43, 0xE5, 0xBA, 0xB3, 0x43,
+	0xE5, 0xBA, 0xB6, 0x43, 0xE5, 0xBB, 0x89, 0x43,
+	0xE5, 0xBB, 0x8A, 0x43, 0xE5, 0xBB, 0x92, 0x43,
+	0xE5, 0xBB, 0x93, 0x43, 0xE5, 0xBB, 0x99, 0x43,
+	0xE5, 0xBB, 0xAC, 0x43, 0xE5, 0xBB, 0xB4, 0x43,
+	0xE5, 0xBB, 0xBE, 0x43, 0xE5, 0xBC, 0x84, 0x43,
+	// Bytes b40 - b7f
+	0xE5, 0xBC, 0x8B, 0x43, 0xE5, 0xBC, 0x93, 0x43,
+	0xE5, 0xBC, 0xA2, 0x43, 0xE5, 0xBD, 0x90, 0x43,
+	0xE5, 0xBD, 0x93, 0x43, 0xE5, 0xBD, 0xA1, 0x43,
+	0xE5, 0xBD, 0xA2, 0x43, 0xE5, 0xBD, 0xA9, 0x43,
+	0xE5, 0xBD, 0xAB, 0x43, 0xE5, 0xBD, 0xB3, 0x43,
+	0xE5, 0xBE, 0x8B, 0x43, 0xE5, 0xBE, 0x8C, 0x43,
+	0xE5, 0xBE, 0x97, 0x43, 0xE5, 0xBE, 0x9A, 0x43,
+	0xE5, 0xBE, 0xA9, 0x43, 0xE5, 0xBE, 0xAD, 0x43,
+	// Bytes b80 - bbf
+	0xE5, 0xBF, 0x83, 0x43, 0xE5, 0xBF, 0x8D, 0x43,
+	0xE5, 0xBF, 0x97, 0x43, 0xE5, 0xBF, 0xB5, 0x43,
+	0xE5, 0xBF, 0xB9, 0x43, 0xE6, 0x80, 0x92, 0x43,
+	0xE6, 0x80, 0x9C, 0x43, 0xE6, 0x81, 0xB5, 0x43,
+	0xE6, 0x82, 0x81, 0x43, 0xE6, 0x82, 0x94, 0x43,
+	0xE6, 0x83, 0x87, 0x43, 0xE6, 0x83, 0x98, 0x43,
+	0xE6, 0x83, 0xA1, 0x43, 0xE6, 0x84, 0x88, 0x43,
+	0xE6, 0x85, 0x84, 0x43, 0xE6, 0x85, 0x88, 0x43,
+	// Bytes bc0 - bff
+	0xE6, 0x85, 0x8C, 0x43, 0xE6, 0x85, 0x8E, 0x43,
+	0xE6, 0x85, 0xA0, 0x43, 0xE6, 0x85, 0xA8, 0x43,
+	0xE6, 0x85, 0xBA, 0x43, 0xE6, 0x86, 0x8E, 0x43,
+	0xE6, 0x86, 0x90, 0x43, 0xE6, 0x86, 0xA4, 0x43,
+	0xE6, 0x86, 0xAF, 0x43, 0xE6, 0x86, 0xB2, 0x43,
+	0xE6, 0x87, 0x9E, 0x43, 0xE6, 0x87, 0xB2, 0x43,
+	0xE6, 0x87, 0xB6, 0x43, 0xE6, 0x88, 0x80, 0x43,
+	0xE6, 0x88, 0x88, 0x43, 0xE6, 0x88, 0x90, 0x43,
+	// Bytes c00 - c3f
+	0xE6, 0x88, 0x9B, 0x43, 0xE6, 0x88, 0xAE, 0x43,
+	0xE6, 0x88, 0xB4, 0x43, 0xE6, 0x88, 0xB6, 0x43,
+	0xE6, 0x89, 0x8B, 0x43, 0xE6, 0x89, 0x93, 0x43,
+	0xE6, 0x89, 0x9D, 0x43, 0xE6, 0x8A, 0x95, 0x43,
+	0xE6, 0x8A, 0xB1, 0x43, 0xE6, 0x8B, 0x89, 0x43,
+	0xE6, 0x8B, 0x8F, 0x43, 0xE6, 0x8B, 0x93, 0x43,
+	0xE6, 0x8B, 0x94, 0x43, 0xE6, 0x8B, 0xBC, 0x43,
+	0xE6, 0x8B, 0xBE, 0x43, 0xE6, 0x8C, 0x87, 0x43,
+	// Bytes c40 - c7f
+	0xE6, 0x8C, 0xBD, 0x43, 0xE6, 0x8D, 0x90, 0x43,
+	0xE6, 0x8D, 0x95, 0x43, 0xE6, 0x8D, 0xA8, 0x43,
+	0xE6, 0x8D, 0xBB, 0x43, 0xE6, 0x8E, 0x83, 0x43,
+	0xE6, 0x8E, 0xA0, 0x43, 0xE6, 0x8E, 0xA9, 0x43,
+	0xE6, 0x8F, 0x84, 0x43, 0xE6, 0x8F, 0x85, 0x43,
+	0xE6, 0x8F, 0xA4, 0x43, 0xE6, 0x90, 0x9C, 0x43,
+	0xE6, 0x90, 0xA2, 0x43, 0xE6, 0x91, 0x92, 0x43,
+	0xE6, 0x91, 0xA9, 0x43, 0xE6, 0x91, 0xB7, 0x43,
+	// Bytes c80 - cbf
+	0xE6, 0x91, 0xBE, 0x43, 0xE6, 0x92, 0x9A, 0x43,
+	0xE6, 0x92, 0x9D, 0x43, 0xE6, 0x93, 0x84, 0x43,
+	0xE6, 0x94, 0xAF, 0x43, 0xE6, 0x94, 0xB4, 0x43,
+	0xE6, 0x95, 0x8F, 0x43, 0xE6, 0x95, 0x96, 0x43,
+	0xE6, 0x95, 0xAC, 0x43, 0xE6, 0x95, 0xB8, 0x43,
+	0xE6, 0x96, 0x87, 0x43, 0xE6, 0x96, 0x97, 0x43,
+	0xE6, 0x96, 0x99, 0x43, 0xE6, 0x96, 0xA4, 0x43,
+	0xE6, 0x96, 0xB0, 0x43, 0xE6, 0x96, 0xB9, 0x43,
+	// Bytes cc0 - cff
+	0xE6, 0x97, 0x85, 0x43, 0xE6, 0x97, 0xA0, 0x43,
+	0xE6, 0x97, 0xA2, 0x43, 0xE6, 0x97, 0xA3, 0x43,
+	0xE6, 0x97, 0xA5, 0x43, 0xE6, 0x98, 0x93, 0x43,
+	0xE6, 0x98, 0xA0, 0x43, 0xE6, 0x99, 0x89, 0x43,
+	0xE6, 0x99, 0xB4, 0x43, 0xE6, 0x9A, 0x88, 0x43,
+	0xE6, 0x9A, 0x91, 0x43, 0xE6, 0x9A, 0x9C, 0x43,
+	0xE6, 0x9A, 0xB4, 0x43, 0xE6, 0x9B, 0x86, 0x43,
+	0xE6, 0x9B, 0xB0, 0x43, 0xE6, 0x9B, 0xB4, 0x43,
+	// Bytes d00 - d3f
+	0xE6, 0x9B, 0xB8, 0x43, 0xE6, 0x9C, 0x80, 0x43,
+	0xE6, 0x9C, 0x88, 0x43, 0xE6, 0x9C, 0x89, 0x43,
+	0xE6, 0x9C, 0x97, 0x43, 0xE6, 0x9C, 0x9B, 0x43,
+	0xE6, 0x9C, 0xA1, 0x43, 0xE6, 0x9C, 0xA8, 0x43,
+	0xE6, 0x9D, 0x8E, 0x43, 0xE6, 0x9D, 0x93, 0x43,
+	0xE6, 0x9D, 0x96, 0x43, 0xE6, 0x9D, 0x9E, 0x43,
+	0xE6, 0x9D, 0xBB, 0x43, 0xE6, 0x9E, 0x85, 0x43,
+	0xE6, 0x9E, 0x97, 0x43, 0xE6, 0x9F, 0xB3, 0x43,
+	// Bytes d40 - d7f
+	0xE6, 0x9F, 0xBA, 0x43, 0xE6, 0xA0, 0x97, 0x43,
+	0xE6, 0xA0, 0x9F, 0x43, 0xE6, 0xA0, 0xAA, 0x43,
+	0xE6, 0xA1, 0x92, 0x43, 0xE6, 0xA2, 0x81, 0x43,
+	0xE6, 0xA2, 0x85, 0x43, 0xE6, 0xA2, 0x8E, 0x43,
+	0xE6, 0xA2, 0xA8, 0x43, 0xE6, 0xA4, 0x94, 0x43,
+	0xE6, 0xA5, 0x82, 0x43, 0xE6, 0xA6, 0xA3, 0x43,
+	0xE6, 0xA7, 0xAA, 0x43, 0xE6, 0xA8, 0x82, 0x43,
+	0xE6, 0xA8, 0x93, 0x43, 0xE6, 0xAA, 0xA8, 0x43,
+	// Bytes d80 - dbf
+	0xE6, 0xAB, 0x93, 0x43, 0xE6, 0xAB, 0x9B, 0x43,
+	0xE6, 0xAC, 0x84, 0x43, 0xE6, 0xAC, 0xA0, 0x43,
+	0xE6, 0xAC, 0xA1, 0x43, 0xE6, 0xAD, 0x94, 0x43,
+	0xE6, 0xAD, 0xA2, 0x43, 0xE6, 0xAD, 0xA3, 0x43,
+	0xE6, 0xAD, 0xB2, 0x43, 0xE6, 0xAD, 0xB7, 0x43,
+	0xE6, 0xAD, 0xB9, 0x43, 0xE6, 0xAE, 0x9F, 0x43,
+	0xE6, 0xAE, 0xAE, 0x43, 0xE6, 0xAE, 0xB3, 0x43,
+	0xE6, 0xAE, 0xBA, 0x43, 0xE6, 0xAE, 0xBB, 0x43,
+	// Bytes dc0 - dff
+	0xE6, 0xAF, 0x8B, 0x43, 0xE6, 0xAF, 0x8D, 0x43,
+	0xE6, 0xAF, 0x94, 0x43, 0xE6, 0xAF, 0x9B, 0x43,
+	0xE6, 0xB0, 0x8F, 0x43, 0xE6, 0xB0, 0x94, 0x43,
+	0xE6, 0xB0, 0xB4, 0x43, 0xE6, 0xB1, 0x8E, 0x43,
+	0xE6, 0xB1, 0xA7, 0x43, 0xE6, 0xB2, 0x88, 0x43,
+	0xE6, 0xB2, 0xBF, 0x43, 0xE6, 0xB3, 0x8C, 0x43,
+	0xE6, 0xB3, 0x8D, 0x43, 0xE6, 0xB3, 0xA5, 0x43,
+	0xE6, 0xB3, 0xA8, 0x43, 0xE6, 0xB4, 0x96, 0x43,
+	// Bytes e00 - e3f
+	0xE6, 0xB4, 0x9B, 0x43, 0xE6, 0xB4, 0x9E, 0x43,
+	0xE6, 0xB4, 0xB4, 0x43, 0xE6, 0xB4, 0xBE, 0x43,
+	0xE6, 0xB5, 0x81, 0x43, 0xE6, 0xB5, 0xA9, 0x43,
+	0xE6, 0xB5, 0xAA, 0x43, 0xE6, 0xB5, 0xB7, 0x43,
+	0xE6, 0xB5, 0xB8, 0x43, 0xE6, 0xB6, 0x85, 0x43,
+	0xE6, 0xB7, 0x8B, 0x43, 0xE6, 0xB7, 0x9A, 0x43,
+	0xE6, 0xB7, 0xAA, 0x43, 0xE6, 0xB7, 0xB9, 0x43,
+	0xE6, 0xB8, 0x9A, 0x43, 0xE6, 0xB8, 0xAF, 0x43,
+	// Bytes e40 - e7f
+	0xE6, 0xB9, 0xAE, 0x43, 0xE6, 0xBA, 0x80, 0x43,
+	0xE6, 0xBA, 0x9C, 0x43, 0xE6, 0xBA, 0xBA, 0x43,
+	0xE6, 0xBB, 0x87, 0x43, 0xE6, 0xBB, 0x8B, 0x43,
+	0xE6, 0xBB, 0x91, 0x43, 0xE6, 0xBB, 0x9B, 0x43,
+	0xE6, 0xBC, 0x8F, 0x43, 0xE6, 0xBC, 0x94, 0x43,
+	0xE6, 0xBC, 0xA2, 0x43, 0xE6, 0xBC, 0xA3, 0x43,
+	0xE6, 0xBD, 0xAE, 0x43, 0xE6, 0xBF, 0x86, 0x43,
+	0xE6, 0xBF, 0xAB, 0x43, 0xE6, 0xBF, 0xBE, 0x43,
+	// Bytes e80 - ebf
+	0xE7, 0x80, 0x9B, 0x43, 0xE7, 0x80, 0x9E, 0x43,
+	0xE7, 0x80, 0xB9, 0x43, 0xE7, 0x81, 0x8A, 0x43,
+	0xE7, 0x81, 0xAB, 0x43, 0xE7, 0x81, 0xB0, 0x43,
+	0xE7, 0x81, 0xB7, 0x43, 0xE7, 0x81, 0xBD, 0x43,
+	0xE7, 0x82, 0x99, 0x43, 0xE7, 0x82, 0xAD, 0x43,
+	0xE7, 0x83, 0x88, 0x43, 0xE7, 0x83, 0x99, 0x43,
+	0xE7, 0x84, 0xA1, 0x43, 0xE7, 0x85, 0x85, 0x43,
+	0xE7, 0x85, 0x89, 0x43, 0xE7, 0x85, 0xAE, 0x43,
+	// Bytes ec0 - eff
+	0xE7, 0x86, 0x9C, 0x43, 0xE7, 0x87, 0x8E, 0x43,
+	0xE7, 0x87, 0x90, 0x43, 0xE7, 0x88, 0x90, 0x43,
+	0xE7, 0x88, 0x9B, 0x43, 0xE7, 0x88, 0xA8, 0x43,
+	0xE7, 0x88, 0xAA, 0x43, 0xE7, 0x88, 0xAB, 0x43,
+	0xE7, 0x88, 0xB5, 0x43, 0xE7, 0x88, 0xB6, 0x43,
+	0xE7, 0x88, 0xBB, 0x43, 0xE7, 0x88, 0xBF, 0x43,
+	0xE7, 0x89, 0x87, 0x43, 0xE7, 0x89, 0x90, 0x43,
+	0xE7, 0x89, 0x99, 0x43, 0xE7, 0x89, 0x9B, 0x43,
+	// Bytes f00 - f3f
+	0xE7, 0x89, 0xA2, 0x43, 0xE7, 0x89, 0xB9, 0x43,
+	0xE7, 0x8A, 0x80, 0x43, 0xE7, 0x8A, 0x95, 0x43,
+	0xE7, 0x8A, 0xAC, 0x43, 0xE7, 0x8A, 0xAF, 0x43,
+	0xE7, 0x8B, 0x80, 0x43, 0xE7, 0x8B, 0xBC, 0x43,
+	0xE7, 0x8C, 0xAA, 0x43, 0xE7, 0x8D, 0xB5, 0x43,
+	0xE7, 0x8D, 0xBA, 0x43, 0xE7, 0x8E, 0x84, 0x43,
+	0xE7, 0x8E, 0x87, 0x43, 0xE7, 0x8E, 0x89, 0x43,
+	0xE7, 0x8E, 0x8B, 0x43, 0xE7, 0x8E, 0xA5, 0x43,
+	// Bytes f40 - f7f
+	0xE7, 0x8E, 0xB2, 0x43, 0xE7, 0x8F, 0x9E, 0x43,
+	0xE7, 0x90, 0x86, 0x43, 0xE7, 0x90, 0x89, 0x43,
+	0xE7, 0x90, 0xA2, 0x43, 0xE7, 0x91, 0x87, 0x43,
+	0xE7, 0x91, 0x9C, 0x43, 0xE7, 0x91, 0xA9, 0x43,
+	0xE7, 0x91, 0xB1, 0x43, 0xE7, 0x92, 0x85, 0x43,
+	0xE7, 0x92, 0x89, 0x43, 0xE7, 0x92, 0x98, 0x43,
+	0xE7, 0x93, 0x8A, 0x43, 0xE7, 0x93, 0x9C, 0x43,
+	0xE7, 0x93, 0xA6, 0x43, 0xE7, 0x94, 0x86, 0x43,
+	// Bytes f80 - fbf
+	0xE7, 0x94, 0x98, 0x43, 0xE7, 0x94, 0x9F, 0x43,
+	0xE7, 0x94, 0xA4, 0x43, 0xE7, 0x94, 0xA8, 0x43,
+	0xE7, 0x94, 0xB0, 0x43, 0xE7, 0x94, 0xB2, 0x43,
+	0xE7, 0x94, 0xB3, 0x43, 0xE7, 0x94, 0xB7, 0x43,
+	0xE7, 0x94, 0xBB, 0x43, 0xE7, 0x94, 0xBE, 0x43,
+	0xE7, 0x95, 0x99, 0x43, 0xE7, 0x95, 0xA5, 0x43,
+	0xE7, 0x95, 0xB0, 0x43, 0xE7, 0x96, 0x8B, 0x43,
+	0xE7, 0x96, 0x92, 0x43, 0xE7, 0x97, 0xA2, 0x43,
+	// Bytes fc0 - fff
+	0xE7, 0x98, 0x90, 0x43, 0xE7, 0x98, 0x9D, 0x43,
+	0xE7, 0x98, 0x9F, 0x43, 0xE7, 0x99, 0x82, 0x43,
+	0xE7, 0x99, 0xA9, 0x43, 0xE7, 0x99, 0xB6, 0x43,
+	0xE7, 0x99, 0xBD, 0x43, 0xE7, 0x9A, 0xAE, 0x43,
+	0xE7, 0x9A, 0xBF, 0x43, 0xE7, 0x9B, 0x8A, 0x43,
+	0xE7, 0x9B, 0x9B, 0x43, 0xE7, 0x9B, 0xA3, 0x43,
+	0xE7, 0x9B, 0xA7, 0x43, 0xE7, 0x9B, 0xAE, 0x43,
+	0xE7, 0x9B, 0xB4, 0x43, 0xE7, 0x9C, 0x81, 0x43,
+	// Bytes 1000 - 103f
+	0xE7, 0x9C, 0x9E, 0x43, 0xE7, 0x9C, 0x9F, 0x43,
+	0xE7, 0x9D, 0x80, 0x43, 0xE7, 0x9D, 0x8A, 0x43,
+	0xE7, 0x9E, 0x8B, 0x43, 0xE7, 0x9E, 0xA7, 0x43,
+	0xE7, 0x9F, 0x9B, 0x43, 0xE7, 0x9F, 0xA2, 0x43,
+	0xE7, 0x9F, 0xB3, 0x43, 0xE7, 0xA1, 0x8E, 0x43,
+	0xE7, 0xA1, 0xAB, 0x43, 0xE7, 0xA2, 0x8C, 0x43,
+	0xE7, 0xA2, 0x91, 0x43, 0xE7, 0xA3, 0x8A, 0x43,
+	0xE7, 0xA3, 0x8C, 0x43, 0xE7, 0xA3, 0xBB, 0x43,
+	// Bytes 1040 - 107f
+	0xE7, 0xA4, 0xAA, 0x43, 0xE7, 0xA4, 0xBA, 0x43,
+	0xE7, 0xA4, 0xBC, 0x43, 0xE7, 0xA4, 0xBE, 0x43,
+	0xE7, 0xA5, 0x88, 0x43, 0xE7, 0xA5, 0x89, 0x43,
+	0xE7, 0xA5, 0x90, 0x43, 0xE7, 0xA5, 0x96, 0x43,
+	0xE7, 0xA5, 0x9D, 0x43, 0xE7, 0xA5, 0x9E, 0x43,
+	0xE7, 0xA5, 0xA5, 0x43, 0xE7, 0xA5, 0xBF, 0x43,
+	0xE7, 0xA6, 0x81, 0x43, 0xE7, 0xA6, 0x8D, 0x43,
+	0xE7, 0xA6, 0x8E, 0x43, 0xE7, 0xA6, 0x8F, 0x43,
+	// Bytes 1080 - 10bf
+	0xE7, 0xA6, 0xAE, 0x43, 0xE7, 0xA6, 0xB8, 0x43,
+	0xE7, 0xA6, 0xBE, 0x43, 0xE7, 0xA7, 0x8A, 0x43,
+	0xE7, 0xA7, 0x98, 0x43, 0xE7, 0xA7, 0xAB, 0x43,
+	0xE7, 0xA8, 0x9C, 0x43, 0xE7, 0xA9, 0x80, 0x43,
+	0xE7, 0xA9, 0x8A, 0x43, 0xE7, 0xA9, 0x8F, 0x43,
+	0xE7, 0xA9, 0xB4, 0x43, 0xE7, 0xA9, 0xBA, 0x43,
+	0xE7, 0xAA, 0x81, 0x43, 0xE7, 0xAA, 0xB1, 0x43,
+	0xE7, 0xAB, 0x8B, 0x43, 0xE7, 0xAB, 0xAE, 0x43,
+	// Bytes 10c0 - 10ff
+	0xE7, 0xAB, 0xB9, 0x43, 0xE7, 0xAC, 0xA0, 0x43,
+	0xE7, 0xAE, 0x8F, 0x43, 0xE7, 0xAF, 0x80, 0x43,
+	0xE7, 0xAF, 0x86, 0x43, 0xE7, 0xAF, 0x89, 0x43,
+	0xE7, 0xB0, 0xBE, 0x43, 0xE7, 0xB1, 0xA0, 0x43,
+	0xE7, 0xB1, 0xB3, 0x43, 0xE7, 0xB1, 0xBB, 0x43,
+	0xE7, 0xB2, 0x92, 0x43, 0xE7, 0xB2, 0xBE, 0x43,
+	0xE7, 0xB3, 0x92, 0x43, 0xE7, 0xB3, 0x96, 0x43,
+	0xE7, 0xB3, 0xA3, 0x43, 0xE7, 0xB3, 0xA7, 0x43,
+	// Bytes 1100 - 113f
+	0xE7, 0xB3, 0xA8, 0x43, 0xE7, 0xB3, 0xB8, 0x43,
+	0xE7, 0xB4, 0x80, 0x43, 0xE7, 0xB4, 0x90, 0x43,
+	0xE7, 0xB4, 0xA2, 0x43, 0xE7, 0xB4, 0xAF, 0x43,
+	0xE7, 0xB5, 0x82, 0x43, 0xE7, 0xB5, 0x9B, 0x43,
+	0xE7, 0xB5, 0xA3, 0x43, 0xE7, 0xB6, 0xA0, 0x43,
+	0xE7, 0xB6, 0xBE, 0x43, 0xE7, 0xB7, 0x87, 0x43,
+	0xE7, 0xB7, 0xB4, 0x43, 0xE7, 0xB8, 0x82, 0x43,
+	0xE7, 0xB8, 0x89, 0x43, 0xE7, 0xB8, 0xB7, 0x43,
+	// Bytes 1140 - 117f
+	0xE7, 0xB9, 0x81, 0x43, 0xE7, 0xB9, 0x85, 0x43,
+	0xE7, 0xBC, 0xB6, 0x43, 0xE7, 0xBC, 0xBE, 0x43,
+	0xE7, 0xBD, 0x91, 0x43, 0xE7, 0xBD, 0xB2, 0x43,
+	0xE7, 0xBD, 0xB9, 0x43, 0xE7, 0xBD, 0xBA, 0x43,
+	0xE7, 0xBE, 0x85, 0x43, 0xE7, 0xBE, 0x8A, 0x43,
+	0xE7, 0xBE, 0x95, 0x43, 0xE7, 0xBE, 0x9A, 0x43,
+	0xE7, 0xBE, 0xBD, 0x43, 0xE7, 0xBF, 0xBA, 0x43,
+	0xE8, 0x80, 0x81, 0x43, 0xE8, 0x80, 0x85, 0x43,
+	// Bytes 1180 - 11bf
+	0xE8, 0x80, 0x8C, 0x43, 0xE8, 0x80, 0x92, 0x43,
+	0xE8, 0x80, 0xB3, 0x43, 0xE8, 0x81, 0x86, 0x43,
+	0xE8, 0x81, 0xA0, 0x43, 0xE8, 0x81, 0xAF, 0x43,
+	0xE8, 0x81, 0xB0, 0x43, 0xE8, 0x81, 0xBE, 0x43,
+	0xE8, 0x81, 0xBF, 0x43, 0xE8, 0x82, 0x89, 0x43,
+	0xE8, 0x82, 0x8B, 0x43, 0xE8, 0x82, 0xAD, 0x43,
+	0xE8, 0x82, 0xB2, 0x43, 0xE8, 0x84, 0x83, 0x43,
+	0xE8, 0x84, 0xBE, 0x43, 0xE8, 0x87, 0x98, 0x43,
+	// Bytes 11c0 - 11ff
+	0xE8, 0x87, 0xA3, 0x43, 0xE8, 0x87, 0xA8, 0x43,
+	0xE8, 0x87, 0xAA, 0x43, 0xE8, 0x87, 0xAD, 0x43,
+	0xE8, 0x87, 0xB3, 0x43, 0xE8, 0x87, 0xBC, 0x43,
+	0xE8, 0x88, 0x81, 0x43, 0xE8, 0x88, 0x84, 0x43,
+	0xE8, 0x88, 0x8C, 0x43, 0xE8, 0x88, 0x98, 0x43,
+	0xE8, 0x88, 0x9B, 0x43, 0xE8, 0x88, 0x9F, 0x43,
+	0xE8, 0x89, 0xAE, 0x43, 0xE8, 0x89, 0xAF, 0x43,
+	0xE8, 0x89, 0xB2, 0x43, 0xE8, 0x89, 0xB8, 0x43,
+	// Bytes 1200 - 123f
+	0xE8, 0x89, 0xB9, 0x43, 0xE8, 0x8A, 0x8B, 0x43,
+	0xE8, 0x8A, 0x91, 0x43, 0xE8, 0x8A, 0x9D, 0x43,
+	0xE8, 0x8A, 0xB1, 0x43, 0xE8, 0x8A, 0xB3, 0x43,
+	0xE8, 0x8A, 0xBD, 0x43, 0xE8, 0x8B, 0xA5, 0x43,
+	0xE8, 0x8B, 0xA6, 0x43, 0xE8, 0x8C, 0x9D, 0x43,
+	0xE8, 0x8C, 0xA3, 0x43, 0xE8, 0x8C, 0xB6, 0x43,
+	0xE8, 0x8D, 0x92, 0x43, 0xE8, 0x8D, 0x93, 0x43,
+	0xE8, 0x8D, 0xA3, 0x43, 0xE8, 0x8E, 0xAD, 0x43,
+	// Bytes 1240 - 127f
+	0xE8, 0x8E, 0xBD, 0x43, 0xE8, 0x8F, 0x89, 0x43,
+	0xE8, 0x8F, 0x8A, 0x43, 0xE8, 0x8F, 0x8C, 0x43,
+	0xE8, 0x8F, 0x9C, 0x43, 0xE8, 0x8F, 0xA7, 0x43,
+	0xE8, 0x8F, 0xAF, 0x43, 0xE8, 0x8F, 0xB1, 0x43,
+	0xE8, 0x90, 0xBD, 0x43, 0xE8, 0x91, 0x89, 0x43,
+	0xE8, 0x91, 0x97, 0x43, 0xE8, 0x93, 0xAE, 0x43,
+	0xE8, 0x93, 0xB1, 0x43, 0xE8, 0x93, 0xB3, 0x43,
+	0xE8, 0x93, 0xBC, 0x43, 0xE8, 0x94, 0x96, 0x43,
+	// Bytes 1280 - 12bf
+	0xE8, 0x95, 0xA4, 0x43, 0xE8, 0x97, 0x8D, 0x43,
+	0xE8, 0x97, 0xBA, 0x43, 0xE8, 0x98, 0x86, 0x43,
+	0xE8, 0x98, 0x92, 0x43, 0xE8, 0x98, 0xAD, 0x43,
+	0xE8, 0x98, 0xBF, 0x43, 0xE8, 0x99, 0x8D, 0x43,
+	0xE8, 0x99, 0x90, 0x43, 0xE8, 0x99, 0x9C, 0x43,
+	0xE8, 0x99, 0xA7, 0x43, 0xE8, 0x99, 0xA9, 0x43,
+	0xE8, 0x99, 0xAB, 0x43, 0xE8, 0x9A, 0x88, 0x43,
+	0xE8, 0x9A, 0xA9, 0x43, 0xE8, 0x9B, 0xA2, 0x43,
+	// Bytes 12c0 - 12ff
+	0xE8, 0x9C, 0x8E, 0x43, 0xE8, 0x9C, 0xA8, 0x43,
+	0xE8, 0x9D, 0xAB, 0x43, 0xE8, 0x9D, 0xB9, 0x43,
+	0xE8, 0x9E, 0x86, 0x43, 0xE8, 0x9E, 0xBA, 0x43,
+	0xE8, 0x9F, 0xA1, 0x43, 0xE8, 0xA0, 0x81, 0x43,
+	0xE8, 0xA0, 0x9F, 0x43, 0xE8, 0xA1, 0x80, 0x43,
+	0xE8, 0xA1, 0x8C, 0x43, 0xE8, 0xA1, 0xA0, 0x43,
+	0xE8, 0xA1, 0xA3, 0x43, 0xE8, 0xA3, 0x82, 0x43,
+	0xE8, 0xA3, 0x8F, 0x43, 0xE8, 0xA3, 0x97, 0x43,
+	// Bytes 1300 - 133f
+	0xE8, 0xA3, 0x9E, 0x43, 0xE8, 0xA3, 0xA1, 0x43,
+	0xE8, 0xA3, 0xB8, 0x43, 0xE8, 0xA3, 0xBA, 0x43,
+	0xE8, 0xA4, 0x90, 0x43, 0xE8, 0xA5, 0x81, 0x43,
+	0xE8, 0xA5, 0xA4, 0x43, 0xE8, 0xA5, 0xBE, 0x43,
+	0xE8, 0xA6, 0x86, 0x43, 0xE8, 0xA6, 0x8B, 0x43,
+	0xE8, 0xA6, 0x96, 0x43, 0xE8, 0xA7, 0x92, 0x43,
+	0xE8, 0xA7, 0xA3, 0x43, 0xE8, 0xA8, 0x80, 0x43,
+	0xE8, 0xAA, 0xA0, 0x43, 0xE8, 0xAA, 0xAA, 0x43,
+	// Bytes 1340 - 137f
+	0xE8, 0xAA, 0xBF, 0x43, 0xE8, 0xAB, 0x8B, 0x43,
+	0xE8, 0xAB, 0x92, 0x43, 0xE8, 0xAB, 0x96, 0x43,
+	0xE8, 0xAB, 0xAD, 0x43, 0xE8, 0xAB, 0xB8, 0x43,
+	0xE8, 0xAB, 0xBE, 0x43, 0xE8, 0xAC, 0x81, 0x43,
+	0xE8, 0xAC, 0xB9, 0x43, 0xE8, 0xAD, 0x98, 0x43,
+	0xE8, 0xAE, 0x80, 0x43, 0xE8, 0xAE, 0x8A, 0x43,
+	0xE8, 0xB0, 0xB7, 0x43, 0xE8, 0xB1, 0x86, 0x43,
+	0xE8, 0xB1, 0x88, 0x43, 0xE8, 0xB1, 0x95, 0x43,
+	// Bytes 1380 - 13bf
+	0xE8, 0xB1, 0xB8, 0x43, 0xE8, 0xB2, 0x9D, 0x43,
+	0xE8, 0xB2, 0xA1, 0x43, 0xE8, 0xB2, 0xA9, 0x43,
+	0xE8, 0xB2, 0xAB, 0x43, 0xE8, 0xB3, 0x81, 0x43,
+	0xE8, 0xB3, 0x82, 0x43, 0xE8, 0xB3, 0x87, 0x43,
+	0xE8, 0xB3, 0x88, 0x43, 0xE8, 0xB3, 0x93, 0x43,
+	0xE8, 0xB4, 0x88, 0x43, 0xE8, 0xB4, 0x9B, 0x43,
+	0xE8, 0xB5, 0xA4, 0x43, 0xE8, 0xB5, 0xB0, 0x43,
+	0xE8, 0xB5, 0xB7, 0x43, 0xE8, 0xB6, 0xB3, 0x43,
+	// Bytes 13c0 - 13ff
+	0xE8, 0xB6, 0xBC, 0x43, 0xE8, 0xB7, 0x8B, 0x43,
+	0xE8, 0xB7, 0xAF, 0x43, 0xE8, 0xB7, 0xB0, 0x43,
+	0xE8, 0xBA, 0xAB, 0x43, 0xE8, 0xBB, 0x8A, 0x43,
+	0xE8, 0xBB, 0x94, 0x43, 0xE8, 0xBC, 0xA6, 0x43,
+	0xE8, 0xBC, 0xAA, 0x43, 0xE8, 0xBC, 0xB8, 0x43,
+	0xE8, 0xBC, 0xBB, 0x43, 0xE8, 0xBD, 0xA2, 0x43,
+	0xE8, 0xBE, 0x9B, 0x43, 0xE8, 0xBE, 0x9E, 0x43,
+	0xE8, 0xBE, 0xB0, 0x43, 0xE8, 0xBE, 0xB5, 0x43,
+	// Bytes 1400 - 143f
+	0xE8, 0xBE, 0xB6, 0x43, 0xE9, 0x80, 0xA3, 0x43,
+	0xE9, 0x80, 0xB8, 0x43, 0xE9, 0x81, 0x8A, 0x43,
+	0xE9, 0x81, 0xA9, 0x43, 0xE9, 0x81, 0xB2, 0x43,
+	0xE9, 0x81, 0xBC, 0x43, 0xE9, 0x82, 0x8F, 0x43,
+	0xE9, 0x82, 0x91, 0x43, 0xE9, 0x82, 0x94, 0x43,
+	0xE9, 0x83, 0x8E, 0x43, 0xE9, 0x83, 0x9E, 0x43,
+	0xE9, 0x83, 0xB1, 0x43, 0xE9, 0x83, 0xBD, 0x43,
+	0xE9, 0x84, 0x91, 0x43, 0xE9, 0x84, 0x9B, 0x43,
+	// Bytes 1440 - 147f
+	0xE9, 0x85, 0x89, 0x43, 0xE9, 0x85, 0x8D, 0x43,
+	0xE9, 0x85, 0xAA, 0x43, 0xE9, 0x86, 0x99, 0x43,
+	0xE9, 0x86, 0xB4, 0x43, 0xE9, 0x87, 0x86, 0x43,
+	0xE9, 0x87, 0x8C, 0x43, 0xE9, 0x87, 0x8F, 0x43,
+	0xE9, 0x87, 0x91, 0x43, 0xE9, 0x88, 0xB4, 0x43,
+	0xE9, 0x88, 0xB8, 0x43, 0xE9, 0x89, 0xB6, 0x43,
+	0xE9, 0x89, 0xBC, 0x43, 0xE9, 0x8B, 0x97, 0x43,
+	0xE9, 0x8B, 0x98, 0x43, 0xE9, 0x8C, 0x84, 0x43,
+	// Bytes 1480 - 14bf
+	0xE9, 0x8D, 0x8A, 0x43, 0xE9, 0x8F, 0xB9, 0x43,
+	0xE9, 0x90, 0x95, 0x43, 0xE9, 0x95, 0xB7, 0x43,
+	0xE9, 0x96, 0x80, 0x43, 0xE9, 0x96, 0x8B, 0x43,
+	0xE9, 0x96, 0xAD, 0x43, 0xE9, 0x96, 0xB7, 0x43,
+	0xE9, 0x98, 0x9C, 0x43, 0xE9, 0x98, 0xAE, 0x43,
+	0xE9, 0x99, 0x8B, 0x43, 0xE9, 0x99, 0x8D, 0x43,
+	0xE9, 0x99, 0xB5, 0x43, 0xE9, 0x99, 0xB8, 0x43,
+	0xE9, 0x99, 0xBC, 0x43, 0xE9, 0x9A, 0x86, 0x43,
+	// Bytes 14c0 - 14ff
+	0xE9, 0x9A, 0xA3, 0x43, 0xE9, 0x9A, 0xB6, 0x43,
+	0xE9, 0x9A, 0xB7, 0x43, 0xE9, 0x9A, 0xB8, 0x43,
+	0xE9, 0x9A, 0xB9, 0x43, 0xE9, 0x9B, 0x83, 0x43,
+	0xE9, 0x9B, 0xA2, 0x43, 0xE9, 0x9B, 0xA3, 0x43,
+	0xE9, 0x9B, 0xA8, 0x43, 0xE9, 0x9B, 0xB6, 0x43,
+	0xE9, 0x9B, 0xB7, 0x43, 0xE9, 0x9C, 0xA3, 0x43,
+	0xE9, 0x9C, 0xB2, 0x43, 0xE9, 0x9D, 0x88, 0x43,
+	0xE9, 0x9D, 0x91, 0x43, 0xE9, 0x9D, 0x96, 0x43,
+	// Bytes 1500 - 153f
+	0xE9, 0x9D, 0x9E, 0x43, 0xE9, 0x9D, 0xA2, 0x43,
+	0xE9, 0x9D, 0xA9, 0x43, 0xE9, 0x9F, 0x8B, 0x43,
+	0xE9, 0x9F, 0x9B, 0x43, 0xE9, 0x9F, 0xA0, 0x43,
+	0xE9, 0x9F, 0xAD, 0x43, 0xE9, 0x9F, 0xB3, 0x43,
+	0xE9, 0x9F, 0xBF, 0x43, 0xE9, 0xA0, 0x81, 0x43,
+	0xE9, 0xA0, 0x85, 0x43, 0xE9, 0xA0, 0x8B, 0x43,
+	0xE9, 0xA0, 0x98, 0x43, 0xE9, 0xA0, 0xA9, 0x43,
+	0xE9, 0xA0, 0xBB, 0x43, 0xE9, 0xA1, 0x9E, 0x43,
+	// Bytes 1540 - 157f
+	0xE9, 0xA2, 0xA8, 0x43, 0xE9, 0xA3, 0x9B, 0x43,
+	0xE9, 0xA3, 0x9F, 0x43, 0xE9, 0xA3, 0xA2, 0x43,
+	0xE9, 0xA3, 0xAF, 0x43, 0xE9, 0xA3, 0xBC, 0x43,
+	0xE9, 0xA4, 0xA8, 0x43, 0xE9, 0xA4, 0xA9, 0x43,
+	0xE9, 0xA6, 0x96, 0x43, 0xE9, 0xA6, 0x99, 0x43,
+	0xE9, 0xA6, 0xA7, 0x43, 0xE9, 0xA6, 0xAC, 0x43,
+	0xE9, 0xA7, 0x82, 0x43, 0xE9, 0xA7, 0xB1, 0x43,
+	0xE9, 0xA7, 0xBE, 0x43, 0xE9, 0xA9, 0xAA, 0x43,
+	// Bytes 1580 - 15bf
+	0xE9, 0xAA, 0xA8, 0x43, 0xE9, 0xAB, 0x98, 0x43,
+	0xE9, 0xAB, 0x9F, 0x43, 0xE9, 0xAC, 0x92, 0x43,
+	0xE9, 0xAC, 0xA5, 0x43, 0xE9, 0xAC, 0xAF, 0x43,
+	0xE9, 0xAC, 0xB2, 0x43, 0xE9, 0xAC, 0xBC, 0x43,
+	0xE9, 0xAD, 0x9A, 0x43, 0xE9, 0xAD, 0xAF, 0x43,
+	0xE9, 0xB1, 0x80, 0x43, 0xE9, 0xB1, 0x97, 0x43,
+	0xE9, 0xB3, 0xA5, 0x43, 0xE9, 0xB3, 0xBD, 0x43,
+	0xE9, 0xB5, 0xA7, 0x43, 0xE9, 0xB6, 0xB4, 0x43,
+	// Bytes 15c0 - 15ff
+	0xE9, 0xB7, 0xBA, 0x43, 0xE9, 0xB8, 0x9E, 0x43,
+	0xE9, 0xB9, 0xB5, 0x43, 0xE9, 0xB9, 0xBF, 0x43,
+	0xE9, 0xBA, 0x97, 0x43, 0xE9, 0xBA, 0x9F, 0x43,
+	0xE9, 0xBA, 0xA5, 0x43, 0xE9, 0xBA, 0xBB, 0x43,
+	0xE9, 0xBB, 0x83, 0x43, 0xE9, 0xBB, 0x8D, 0x43,
+	0xE9, 0xBB, 0x8E, 0x43, 0xE9, 0xBB, 0x91, 0x43,
+	0xE9, 0xBB, 0xB9, 0x43, 0xE9, 0xBB, 0xBD, 0x43,
+	0xE9, 0xBB, 0xBE, 0x43, 0xE9, 0xBC, 0x85, 0x43,
+	// Bytes 1600 - 163f
+	0xE9, 0xBC, 0x8E, 0x43, 0xE9, 0xBC, 0x8F, 0x43,
+	0xE9, 0xBC, 0x93, 0x43, 0xE9, 0xBC, 0x96, 0x43,
+	0xE9, 0xBC, 0xA0, 0x43, 0xE9, 0xBC, 0xBB, 0x43,
+	0xE9, 0xBD, 0x83, 0x43, 0xE9, 0xBD, 0x8A, 0x43,
+	0xE9, 0xBD, 0x92, 0x43, 0xE9, 0xBE, 0x8D, 0x43,
+	0xE9, 0xBE, 0x8E, 0x43, 0xE9, 0xBE, 0x9C, 0x43,
+	0xE9, 0xBE, 0x9F, 0x43, 0xE9, 0xBE, 0xA0, 0x43,
+	0xEA, 0x9C, 0xA7, 0x43, 0xEA, 0x9D, 0xAF, 0x43,
+	// Bytes 1640 - 167f
+	0xEA, 0xAC, 0xB7, 0x43, 0xEA, 0xAD, 0x92, 0x44,
+	0xF0, 0xA0, 0x84, 0xA2, 0x44, 0xF0, 0xA0, 0x94,
+	0x9C, 0x44, 0xF0, 0xA0, 0x94, 0xA5, 0x44, 0xF0,
+	0xA0, 0x95, 0x8B, 0x44, 0xF0, 0xA0, 0x98, 0xBA,
+	0x44, 0xF0, 0xA0, 0xA0, 0x84, 0x44, 0xF0, 0xA0,
+	0xA3, 0x9E, 0x44, 0xF0, 0xA0, 0xA8, 0xAC, 0x44,
+	0xF0, 0xA0, 0xAD, 0xA3, 0x44, 0xF0, 0xA1, 0x93,
+	0xA4, 0x44, 0xF0, 0xA1, 0x9A, 0xA8, 0x44, 0xF0,
+	// Bytes 1680 - 16bf
+	0xA1, 0x9B, 0xAA, 0x44, 0xF0, 0xA1, 0xA7, 0x88,
+	0x44, 0xF0, 0xA1, 0xAC, 0x98, 0x44, 0xF0, 0xA1,
+	0xB4, 0x8B, 0x44, 0xF0, 0xA1, 0xB7, 0xA4, 0x44,
+	0xF0, 0xA1, 0xB7, 0xA6, 0x44, 0xF0, 0xA2, 0x86,
+	0x83, 0x44, 0xF0, 0xA2, 0x86, 0x9F, 0x44, 0xF0,
+	0xA2, 0x8C, 0xB1, 0x44, 0xF0, 0xA2, 0x9B, 0x94,
+	0x44, 0xF0, 0xA2, 0xA1, 0x84, 0x44, 0xF0, 0xA2,
+	0xA1, 0x8A, 0x44, 0xF0, 0xA2, 0xAC, 0x8C, 0x44,
+	// Bytes 16c0 - 16ff
+	0xF0, 0xA2, 0xAF, 0xB1, 0x44, 0xF0, 0xA3, 0x80,
+	0x8A, 0x44, 0xF0, 0xA3, 0x8A, 0xB8, 0x44, 0xF0,
+	0xA3, 0x8D, 0x9F, 0x44, 0xF0, 0xA3, 0x8E, 0x93,
+	0x44, 0xF0, 0xA3, 0x8E, 0x9C, 0x44, 0xF0, 0xA3,
+	0x8F, 0x83, 0x44, 0xF0, 0xA3, 0x8F, 0x95, 0x44,
+	0xF0, 0xA3, 0x91, 0xAD, 0x44, 0xF0, 0xA3, 0x9A,
+	0xA3, 0x44, 0xF0, 0xA3, 0xA2, 0xA7, 0x44, 0xF0,
+	0xA3, 0xAA, 0x8D, 0x44, 0xF0, 0xA3, 0xAB, 0xBA,
+	// Bytes 1700 - 173f
+	0x44, 0xF0, 0xA3, 0xB2, 0xBC, 0x44, 0xF0, 0xA3,
+	0xB4, 0x9E, 0x44, 0xF0, 0xA3, 0xBB, 0x91, 0x44,
+	0xF0, 0xA3, 0xBD, 0x9E, 0x44, 0xF0, 0xA3, 0xBE,
+	0x8E, 0x44, 0xF0, 0xA4, 0x89, 0xA3, 0x44, 0xF0,
+	0xA4, 0x8B, 0xAE, 0x44, 0xF0, 0xA4, 0x8E, 0xAB,
+	0x44, 0xF0, 0xA4, 0x98, 0x88, 0x44, 0xF0, 0xA4,
+	0x9C, 0xB5, 0x44, 0xF0, 0xA4, 0xA0, 0x94, 0x44,
+	0xF0, 0xA4, 0xB0, 0xB6, 0x44, 0xF0, 0xA4, 0xB2,
+	// Bytes 1740 - 177f
+	0x92, 0x44, 0xF0, 0xA4, 0xBE, 0xA1, 0x44, 0xF0,
+	0xA4, 0xBE, 0xB8, 0x44, 0xF0, 0xA5, 0x81, 0x84,
+	0x44, 0xF0, 0xA5, 0x83, 0xB2, 0x44, 0xF0, 0xA5,
+	0x83, 0xB3, 0x44, 0xF0, 0xA5, 0x84, 0x99, 0x44,
+	0xF0, 0xA5, 0x84, 0xB3, 0x44, 0xF0, 0xA5, 0x89,
+	0x89, 0x44, 0xF0, 0xA5, 0x90, 0x9D, 0x44, 0xF0,
+	0xA5, 0x98, 0xA6, 0x44, 0xF0, 0xA5, 0x9A, 0x9A,
+	0x44, 0xF0, 0xA5, 0x9B, 0x85, 0x44, 0xF0, 0xA5,
+	// Bytes 1780 - 17bf
+	0xA5, 0xBC, 0x44, 0xF0, 0xA5, 0xAA, 0xA7, 0x44,
+	0xF0, 0xA5, 0xAE, 0xAB, 0x44, 0xF0, 0xA5, 0xB2,
+	0x80, 0x44, 0xF0, 0xA5, 0xB3, 0x90, 0x44, 0xF0,
+	0xA5, 0xBE, 0x86, 0x44, 0xF0, 0xA6, 0x87, 0x9A,
+	0x44, 0xF0, 0xA6, 0x88, 0xA8, 0x44, 0xF0, 0xA6,
+	0x89, 0x87, 0x44, 0xF0, 0xA6, 0x8B, 0x99, 0x44,
+	0xF0, 0xA6, 0x8C, 0xBE, 0x44, 0xF0, 0xA6, 0x93,
+	0x9A, 0x44, 0xF0, 0xA6, 0x94, 0xA3, 0x44, 0xF0,
+	// Bytes 17c0 - 17ff
+	0xA6, 0x96, 0xA8, 0x44, 0xF0, 0xA6, 0x9E, 0xA7,
+	0x44, 0xF0, 0xA6, 0x9E, 0xB5, 0x44, 0xF0, 0xA6,
+	0xAC, 0xBC, 0x44, 0xF0, 0xA6, 0xB0, 0xB6, 0x44,
+	0xF0, 0xA6, 0xB3, 0x95, 0x44, 0xF0, 0xA6, 0xB5,
+	0xAB, 0x44, 0xF0, 0xA6, 0xBC, 0xAC, 0x44, 0xF0,
+	0xA6, 0xBE, 0xB1, 0x44, 0xF0, 0xA7, 0x83, 0x92,
+	0x44, 0xF0, 0xA7, 0x8F, 0x8A, 0x44, 0xF0, 0xA7,
+	0x99, 0xA7, 0x44, 0xF0, 0xA7, 0xA2, 0xAE, 0x44,
+	// Bytes 1800 - 183f
+	0xF0, 0xA7, 0xA5, 0xA6, 0x44, 0xF0, 0xA7, 0xB2,
+	0xA8, 0x44, 0xF0, 0xA7, 0xBB, 0x93, 0x44, 0xF0,
+	0xA7, 0xBC, 0xAF, 0x44, 0xF0, 0xA8, 0x97, 0x92,
+	0x44, 0xF0, 0xA8, 0x97, 0xAD, 0x44, 0xF0, 0xA8,
+	0x9C, 0xAE, 0x44, 0xF0, 0xA8, 0xAF, 0xBA, 0x44,
+	0xF0, 0xA8, 0xB5, 0xB7, 0x44, 0xF0, 0xA9, 0x85,
+	0x85, 0x44, 0xF0, 0xA9, 0x87, 0x9F, 0x44, 0xF0,
+	0xA9, 0x88, 0x9A, 0x44, 0xF0, 0xA9, 0x90, 0x8A,
+	// Bytes 1840 - 187f
+	0x44, 0xF0, 0xA9, 0x92, 0x96, 0x44, 0xF0, 0xA9,
+	0x96, 0xB6, 0x44, 0xF0, 0xA9, 0xAC, 0xB0, 0x44,
+	0xF0, 0xAA, 0x83, 0x8E, 0x44, 0xF0, 0xAA, 0x84,
+	0x85, 0x44, 0xF0, 0xAA, 0x88, 0x8E, 0x44, 0xF0,
+	0xAA, 0x8A, 0x91, 0x44, 0xF0, 0xAA, 0x8E, 0x92,
+	0x44, 0xF0, 0xAA, 0x98, 0x80, 0x42, 0x21, 0x21,
+	0x42, 0x21, 0x3F, 0x42, 0x2E, 0x2E, 0x42, 0x30,
+	0x2C, 0x42, 0x30, 0x2E, 0x42, 0x31, 0x2C, 0x42,
+	// Bytes 1880 - 18bf
+	0x31, 0x2E, 0x42, 0x31, 0x30, 0x42, 0x31, 0x31,
+	0x42, 0x31, 0x32, 0x42, 0x31, 0x33, 0x42, 0x31,
+	0x34, 0x42, 0x31, 0x35, 0x42, 0x31, 0x36, 0x42,
+	0x31, 0x37, 0x42, 0x31, 0x38, 0x42, 0x31, 0x39,
+	0x42, 0x32, 0x2C, 0x42, 0x32, 0x2E, 0x42, 0x32,
+	0x30, 0x42, 0x32, 0x31, 0x42, 0x32, 0x32, 0x42,
+	0x32, 0x33, 0x42, 0x32, 0x34, 0x42, 0x32, 0x35,
+	0x42, 0x32, 0x36, 0x42, 0x32, 0x37, 0x42, 0x32,
+	// Bytes 18c0 - 18ff
+	0x38, 0x42, 0x32, 0x39, 0x42, 0x33, 0x2C, 0x42,
+	0x33, 0x2E, 0x42, 0x33, 0x30, 0x42, 0x33, 0x31,
+	0x42, 0x33, 0x32, 0x42, 0x33, 0x33, 0x42, 0x33,
+	0x34, 0x42, 0x33, 0x35, 0x42, 0x33, 0x36, 0x42,
+	0x33, 0x37, 0x42, 0x33, 0x38, 0x42, 0x33, 0x39,
+	0x42, 0x34, 0x2C, 0x42, 0x34, 0x2E, 0x42, 0x34,
+	0x30, 0x42, 0x34, 0x31, 0x42, 0x34, 0x32, 0x42,
+	0x34, 0x33, 0x42, 0x34, 0x34, 0x42, 0x34, 0x35,
+	// Bytes 1900 - 193f
+	0x42, 0x34, 0x36, 0x42, 0x34, 0x37, 0x42, 0x34,
+	0x38, 0x42, 0x34, 0x39, 0x42, 0x35, 0x2C, 0x42,
+	0x35, 0x2E, 0x42, 0x35, 0x30, 0x42, 0x36, 0x2C,
+	0x42, 0x36, 0x2E, 0x42, 0x37, 0x2C, 0x42, 0x37,
+	0x2E, 0x42, 0x38, 0x2C, 0x42, 0x38, 0x2E, 0x42,
+	0x39, 0x2C, 0x42, 0x39, 0x2E, 0x42, 0x3D, 0x3D,
+	0x42, 0x3F, 0x21, 0x42, 0x3F, 0x3F, 0x42, 0x41,
+	0x55, 0x42, 0x42, 0x71, 0x42, 0x43, 0x44, 0x42,
+	// Bytes 1940 - 197f
+	0x44, 0x4A, 0x42, 0x44, 0x5A, 0x42, 0x44, 0x7A,
+	0x42, 0x47, 0x42, 0x42, 0x47, 0x79, 0x42, 0x48,
+	0x50, 0x42, 0x48, 0x56, 0x42, 0x48, 0x67, 0x42,
+	0x48, 0x7A, 0x42, 0x49, 0x49, 0x42, 0x49, 0x4A,
+	0x42, 0x49, 0x55, 0x42, 0x49, 0x56, 0x42, 0x49,
+	0x58, 0x42, 0x4B, 0x42, 0x42, 0x4B, 0x4B, 0x42,
+	0x4B, 0x4D, 0x42, 0x4C, 0x4A, 0x42, 0x4C, 0x6A,
+	0x42, 0x4D, 0x42, 0x42, 0x4D, 0x43, 0x42, 0x4D,
+	// Bytes 1980 - 19bf
+	0x44, 0x42, 0x4D, 0x56, 0x42, 0x4D, 0x57, 0x42,
+	0x4E, 0x4A, 0x42, 0x4E, 0x6A, 0x42, 0x4E, 0x6F,
+	0x42, 0x50, 0x48, 0x42, 0x50, 0x52, 0x42, 0x50,
+	0x61, 0x42, 0x52, 0x73, 0x42, 0x53, 0x44, 0x42,
+	0x53, 0x4D, 0x42, 0x53, 0x53, 0x42, 0x53, 0x76,
+	0x42, 0x54, 0x4D, 0x42, 0x56, 0x49, 0x42, 0x57,
+	0x43, 0x42, 0x57, 0x5A, 0x42, 0x57, 0x62, 0x42,
+	0x58, 0x49, 0x42, 0x63, 0x63, 0x42, 0x63, 0x64,
+	// Bytes 19c0 - 19ff
+	0x42, 0x63, 0x6D, 0x42, 0x64, 0x42, 0x42, 0x64,
+	0x61, 0x42, 0x64, 0x6C, 0x42, 0x64, 0x6D, 0x42,
+	0x64, 0x7A, 0x42, 0x65, 0x56, 0x42, 0x66, 0x66,
+	0x42, 0x66, 0x69, 0x42, 0x66, 0x6C, 0x42, 0x66,
+	0x6D, 0x42, 0x68, 0x61, 0x42, 0x69, 0x69, 0x42,
+	0x69, 0x6A, 0x42, 0x69, 0x6E, 0x42, 0x69, 0x76,
+	0x42, 0x69, 0x78, 0x42, 0x6B, 0x41, 0x42, 0x6B,
+	0x56, 0x42, 0x6B, 0x57, 0x42, 0x6B, 0x67, 0x42,
+	// Bytes 1a00 - 1a3f
+	0x6B, 0x6C, 0x42, 0x6B, 0x6D, 0x42, 0x6B, 0x74,
+	0x42, 0x6C, 0x6A, 0x42, 0x6C, 0x6D, 0x42, 0x6C,
+	0x6E, 0x42, 0x6C, 0x78, 0x42, 0x6D, 0x32, 0x42,
+	0x6D, 0x33, 0x42, 0x6D, 0x41, 0x42, 0x6D, 0x56,
+	0x42, 0x6D, 0x57, 0x42, 0x6D, 0x62, 0x42, 0x6D,
+	0x67, 0x42, 0x6D, 0x6C, 0x42, 0x6D, 0x6D, 0x42,
+	0x6D, 0x73, 0x42, 0x6E, 0x41, 0x42, 0x6E, 0x46,
+	0x42, 0x6E, 0x56, 0x42, 0x6E, 0x57, 0x42, 0x6E,
+	// Bytes 1a40 - 1a7f
+	0x6A, 0x42, 0x6E, 0x6D, 0x42, 0x6E, 0x73, 0x42,
+	0x6F, 0x56, 0x42, 0x70, 0x41, 0x42, 0x70, 0x46,
+	0x42, 0x70, 0x56, 0x42, 0x70, 0x57, 0x42, 0x70,
+	0x63, 0x42, 0x70, 0x73, 0x42, 0x73, 0x72, 0x42,
+	0x73, 0x74, 0x42, 0x76, 0x69, 0x42, 0x78, 0x69,
+	0x43, 0x28, 0x31, 0x29, 0x43, 0x28, 0x32, 0x29,
+	0x43, 0x28, 0x33, 0x29, 0x43, 0x28, 0x34, 0x29,
+	0x43, 0x28, 0x35, 0x29, 0x43, 0x28, 0x36, 0x29,
+	// Bytes 1a80 - 1abf
+	0x43, 0x28, 0x37, 0x29, 0x43, 0x28, 0x38, 0x29,
+	0x43, 0x28, 0x39, 0x29, 0x43, 0x28, 0x41, 0x29,
+	0x43, 0x28, 0x42, 0x29, 0x43, 0x28, 0x43, 0x29,
+	0x43, 0x28, 0x44, 0x29, 0x43, 0x28, 0x45, 0x29,
+	0x43, 0x28, 0x46, 0x29, 0x43, 0x28, 0x47, 0x29,
+	0x43, 0x28, 0x48, 0x29, 0x43, 0x28, 0x49, 0x29,
+	0x43, 0x28, 0x4A, 0x29, 0x43, 0x28, 0x4B, 0x29,
+	0x43, 0x28, 0x4C, 0x29, 0x43, 0x28, 0x4D, 0x29,
+	// Bytes 1ac0 - 1aff
+	0x43, 0x28, 0x4E, 0x29, 0x43, 0x28, 0x4F, 0x29,
+	0x43, 0x28, 0x50, 0x29, 0x43, 0x28, 0x51, 0x29,
+	0x43, 0x28, 0x52, 0x29, 0x43, 0x28, 0x53, 0x29,
+	0x43, 0x28, 0x54, 0x29, 0x43, 0x28, 0x55, 0x29,
+	0x43, 0x28, 0x56, 0x29, 0x43, 0x28, 0x57, 0x29,
+	0x43, 0x28, 0x58, 0x29, 0x43, 0x28, 0x59, 0x29,
+	0x43, 0x28, 0x5A, 0x29, 0x43, 0x28, 0x61, 0x29,
+	0x43, 0x28, 0x62, 0x29, 0x43, 0x28, 0x63, 0x29,
+	// Bytes 1b00 - 1b3f
+	0x43, 0x28, 0x64, 0x29, 0x43, 0x28, 0x65, 0x29,
+	0x43, 0x28, 0x66, 0x29, 0x43, 0x28, 0x67, 0x29,
+	0x43, 0x28, 0x68, 0x29, 0x43, 0x28, 0x69, 0x29,
+	0x43, 0x28, 0x6A, 0x29, 0x43, 0x28, 0x6B, 0x29,
+	0x43, 0x28, 0x6C, 0x29, 0x43, 0x28, 0x6D, 0x29,
+	0x43, 0x28, 0x6E, 0x29, 0x43, 0x28, 0x6F, 0x29,
+	0x43, 0x28, 0x70, 0x29, 0x43, 0x28, 0x71, 0x29,
+	0x43, 0x28, 0x72, 0x29, 0x43, 0x28, 0x73, 0x29,
+	// Bytes 1b40 - 1b7f
+	0x43, 0x28, 0x74, 0x29, 0x43, 0x28, 0x75, 0x29,
+	0x43, 0x28, 0x76, 0x29, 0x43, 0x28, 0x77, 0x29,
+	0x43, 0x28, 0x78, 0x29, 0x43, 0x28, 0x79, 0x29,
+	0x43, 0x28, 0x7A, 0x29, 0x43, 0x2E, 0x2E, 0x2E,
+	0x43, 0x31, 0x30, 0x2E, 0x43, 0x31, 0x31, 0x2E,
+	0x43, 0x31, 0x32, 0x2E, 0x43, 0x31, 0x33, 0x2E,
+	0x43, 0x31, 0x34, 0x2E, 0x43, 0x31, 0x35, 0x2E,
+	0x43, 0x31, 0x36, 0x2E, 0x43, 0x31, 0x37, 0x2E,
+	// Bytes 1b80 - 1bbf
+	0x43, 0x31, 0x38, 0x2E, 0x43, 0x31, 0x39, 0x2E,
+	0x43, 0x32, 0x30, 0x2E, 0x43, 0x3A, 0x3A, 0x3D,
+	0x43, 0x3D, 0x3D, 0x3D, 0x43, 0x43, 0x6F, 0x2E,
+	0x43, 0x46, 0x41, 0x58, 0x43, 0x47, 0x48, 0x7A,
+	0x43, 0x47, 0x50, 0x61, 0x43, 0x49, 0x49, 0x49,
+	0x43, 0x4C, 0x54, 0x44, 0x43, 0x4C, 0xC2, 0xB7,
+	0x43, 0x4D, 0x48, 0x7A, 0x43, 0x4D, 0x50, 0x61,
+	0x43, 0x4D, 0xCE, 0xA9, 0x43, 0x50, 0x50, 0x4D,
+	// Bytes 1bc0 - 1bff
+	0x43, 0x50, 0x50, 0x56, 0x43, 0x50, 0x54, 0x45,
+	0x43, 0x54, 0x45, 0x4C, 0x43, 0x54, 0x48, 0x7A,
+	0x43, 0x56, 0x49, 0x49, 0x43, 0x58, 0x49, 0x49,
+	0x43, 0x61, 0x2F, 0x63, 0x43, 0x61, 0x2F, 0x73,
+	0x43, 0x61, 0xCA, 0xBE, 0x43, 0x62, 0x61, 0x72,
+	0x43, 0x63, 0x2F, 0x6F, 0x43, 0x63, 0x2F, 0x75,
+	0x43, 0x63, 0x61, 0x6C, 0x43, 0x63, 0x6D, 0x32,
+	0x43, 0x63, 0x6D, 0x33, 0x43, 0x64, 0x6D, 0x32,
+	// Bytes 1c00 - 1c3f
+	0x43, 0x64, 0x6D, 0x33, 0x43, 0x65, 0x72, 0x67,
+	0x43, 0x66, 0x66, 0x69, 0x43, 0x66, 0x66, 0x6C,
+	0x43, 0x67, 0x61, 0x6C, 0x43, 0x68, 0x50, 0x61,
+	0x43, 0x69, 0x69, 0x69, 0x43, 0x6B, 0x48, 0x7A,
+	0x43, 0x6B, 0x50, 0x61, 0x43, 0x6B, 0x6D, 0x32,
+	0x43, 0x6B, 0x6D, 0x33, 0x43, 0x6B, 0xCE, 0xA9,
+	0x43, 0x6C, 0x6F, 0x67, 0x43, 0x6C, 0xC2, 0xB7,
+	0x43, 0x6D, 0x69, 0x6C, 0x43, 0x6D, 0x6D, 0x32,
+	// Bytes 1c40 - 1c7f
+	0x43, 0x6D, 0x6D, 0x33, 0x43, 0x6D, 0x6F, 0x6C,
+	0x43, 0x72, 0x61, 0x64, 0x43, 0x76, 0x69, 0x69,
+	0x43, 0x78, 0x69, 0x69, 0x43, 0xC2, 0xB0, 0x43,
+	0x43, 0xC2, 0xB0, 0x46, 0x43, 0xCA, 0xBC, 0x6E,
+	0x43, 0xCE, 0xBC, 0x41, 0x43, 0xCE, 0xBC, 0x46,
+	0x43, 0xCE, 0xBC, 0x56, 0x43, 0xCE, 0xBC, 0x57,
+	0x43, 0xCE, 0xBC, 0x67, 0x43, 0xCE, 0xBC, 0x6C,
+	0x43, 0xCE, 0xBC, 0x6D, 0x43, 0xCE, 0xBC, 0x73,
+	// Bytes 1c80 - 1cbf
+	0x44, 0x28, 0x31, 0x30, 0x29, 0x44, 0x28, 0x31,
+	0x31, 0x29, 0x44, 0x28, 0x31, 0x32, 0x29, 0x44,
+	0x28, 0x31, 0x33, 0x29, 0x44, 0x28, 0x31, 0x34,
+	0x29, 0x44, 0x28, 0x31, 0x35, 0x29, 0x44, 0x28,
+	0x31, 0x36, 0x29, 0x44, 0x28, 0x31, 0x37, 0x29,
+	0x44, 0x28, 0x31, 0x38, 0x29, 0x44, 0x28, 0x31,
+	0x39, 0x29, 0x44, 0x28, 0x32, 0x30, 0x29, 0x44,
+	0x30, 0xE7, 0x82, 0xB9, 0x44, 0x31, 0xE2, 0x81,
+	// Bytes 1cc0 - 1cff
+	0x84, 0x44, 0x31, 0xE6, 0x97, 0xA5, 0x44, 0x31,
+	0xE6, 0x9C, 0x88, 0x44, 0x31, 0xE7, 0x82, 0xB9,
+	0x44, 0x32, 0xE6, 0x97, 0xA5, 0x44, 0x32, 0xE6,
+	0x9C, 0x88, 0x44, 0x32, 0xE7, 0x82, 0xB9, 0x44,
+	0x33, 0xE6, 0x97, 0xA5, 0x44, 0x33, 0xE6, 0x9C,
+	0x88, 0x44, 0x33, 0xE7, 0x82, 0xB9, 0x44, 0x34,
+	0xE6, 0x97, 0xA5, 0x44, 0x34, 0xE6, 0x9C, 0x88,
+	0x44, 0x34, 0xE7, 0x82, 0xB9, 0x44, 0x35, 0xE6,
+	// Bytes 1d00 - 1d3f
+	0x97, 0xA5, 0x44, 0x35, 0xE6, 0x9C, 0x88, 0x44,
+	0x35, 0xE7, 0x82, 0xB9, 0x44, 0x36, 0xE6, 0x97,
+	0xA5, 0x44, 0x36, 0xE6, 0x9C, 0x88, 0x44, 0x36,
+	0xE7, 0x82, 0xB9, 0x44, 0x37, 0xE6, 0x97, 0xA5,
+	0x44, 0x37, 0xE6, 0x9C, 0x88, 0x44, 0x37, 0xE7,
+	0x82, 0xB9, 0x44, 0x38, 0xE6, 0x97, 0xA5, 0x44,
+	0x38, 0xE6, 0x9C, 0x88, 0x44, 0x38, 0xE7, 0x82,
+	0xB9, 0x44, 0x39, 0xE6, 0x97, 0xA5, 0x44, 0x39,
+	// Bytes 1d40 - 1d7f
+	0xE6, 0x9C, 0x88, 0x44, 0x39, 0xE7, 0x82, 0xB9,
+	0x44, 0x56, 0x49, 0x49, 0x49, 0x44, 0x61, 0x2E,
+	0x6D, 0x2E, 0x44, 0x6B, 0x63, 0x61, 0x6C, 0x44,
+	0x70, 0x2E, 0x6D, 0x2E, 0x44, 0x76, 0x69, 0x69,
+	0x69, 0x44, 0xD5, 0xA5, 0xD6, 0x82, 0x44, 0xD5,
+	0xB4, 0xD5, 0xA5, 0x44, 0xD5, 0xB4, 0xD5, 0xAB,
+	0x44, 0xD5, 0xB4, 0xD5, 0xAD, 0x44, 0xD5, 0xB4,
+	0xD5, 0xB6, 0x44, 0xD5, 0xBE, 0xD5, 0xB6, 0x44,
+	// Bytes 1d80 - 1dbf
+	0xD7, 0x90, 0xD7, 0x9C, 0x44, 0xD8, 0xA7, 0xD9,
+	0xB4, 0x44, 0xD8, 0xA8, 0xD8, 0xAC, 0x44, 0xD8,
+	0xA8, 0xD8, 0xAD, 0x44, 0xD8, 0xA8, 0xD8, 0xAE,
+	0x44, 0xD8, 0xA8, 0xD8, 0xB1, 0x44, 0xD8, 0xA8,
+	0xD8, 0xB2, 0x44, 0xD8, 0xA8, 0xD9, 0x85, 0x44,
+	0xD8, 0xA8, 0xD9, 0x86, 0x44, 0xD8, 0xA8, 0xD9,
+	0x87, 0x44, 0xD8, 0xA8, 0xD9, 0x89, 0x44, 0xD8,
+	0xA8, 0xD9, 0x8A, 0x44, 0xD8, 0xAA, 0xD8, 0xAC,
+	// Bytes 1dc0 - 1dff
+	0x44, 0xD8, 0xAA, 0xD8, 0xAD, 0x44, 0xD8, 0xAA,
+	0xD8, 0xAE, 0x44, 0xD8, 0xAA, 0xD8, 0xB1, 0x44,
+	0xD8, 0xAA, 0xD8, 0xB2, 0x44, 0xD8, 0xAA, 0xD9,
+	0x85, 0x44, 0xD8, 0xAA, 0xD9, 0x86, 0x44, 0xD8,
+	0xAA, 0xD9, 0x87, 0x44, 0xD8, 0xAA, 0xD9, 0x89,
+	0x44, 0xD8, 0xAA, 0xD9, 0x8A, 0x44, 0xD8, 0xAB,
+	0xD8, 0xAC, 0x44, 0xD8, 0xAB, 0xD8, 0xB1, 0x44,
+	0xD8, 0xAB, 0xD8, 0xB2, 0x44, 0xD8, 0xAB, 0xD9,
+	// Bytes 1e00 - 1e3f
+	0x85, 0x44, 0xD8, 0xAB, 0xD9, 0x86, 0x44, 0xD8,
+	0xAB, 0xD9, 0x87, 0x44, 0xD8, 0xAB, 0xD9, 0x89,
+	0x44, 0xD8, 0xAB, 0xD9, 0x8A, 0x44, 0xD8, 0xAC,
+	0xD8, 0xAD, 0x44, 0xD8, 0xAC, 0xD9, 0x85, 0x44,
+	0xD8, 0xAC, 0xD9, 0x89, 0x44, 0xD8, 0xAC, 0xD9,
+	0x8A, 0x44, 0xD8, 0xAD, 0xD8, 0xAC, 0x44, 0xD8,
+	0xAD, 0xD9, 0x85, 0x44, 0xD8, 0xAD, 0xD9, 0x89,
+	0x44, 0xD8, 0xAD, 0xD9, 0x8A, 0x44, 0xD8, 0xAE,
+	// Bytes 1e40 - 1e7f
+	0xD8, 0xAC, 0x44, 0xD8, 0xAE, 0xD8, 0xAD, 0x44,
+	0xD8, 0xAE, 0xD9, 0x85, 0x44, 0xD8, 0xAE, 0xD9,
+	0x89, 0x44, 0xD8, 0xAE, 0xD9, 0x8A, 0x44, 0xD8,
+	0xB3, 0xD8, 0xAC, 0x44, 0xD8, 0xB3, 0xD8, 0xAD,
+	0x44, 0xD8, 0xB3, 0xD8, 0xAE, 0x44, 0xD8, 0xB3,
+	0xD8, 0xB1, 0x44, 0xD8, 0xB3, 0xD9, 0x85, 0x44,
+	0xD8, 0xB3, 0xD9, 0x87, 0x44, 0xD8, 0xB3, 0xD9,
+	0x89, 0x44, 0xD8, 0xB3, 0xD9, 0x8A, 0x44, 0xD8,
+	// Bytes 1e80 - 1ebf
+	0xB4, 0xD8, 0xAC, 0x44, 0xD8, 0xB4, 0xD8, 0xAD,
+	0x44, 0xD8, 0xB4, 0xD8, 0xAE, 0x44, 0xD8, 0xB4,
+	0xD8, 0xB1, 0x44, 0xD8, 0xB4, 0xD9, 0x85, 0x44,
+	0xD8, 0xB4, 0xD9, 0x87, 0x44, 0xD8, 0xB4, 0xD9,
+	0x89, 0x44, 0xD8, 0xB4, 0xD9, 0x8A, 0x44, 0xD8,
+	0xB5, 0xD8, 0xAD, 0x44, 0xD8, 0xB5, 0xD8, 0xAE,
+	0x44, 0xD8, 0xB5, 0xD8, 0xB1, 0x44, 0xD8, 0xB5,
+	0xD9, 0x85, 0x44, 0xD8, 0xB5, 0xD9, 0x89, 0x44,
+	// Bytes 1ec0 - 1eff
+	0xD8, 0xB5, 0xD9, 0x8A, 0x44, 0xD8, 0xB6, 0xD8,
+	0xAC, 0x44, 0xD8, 0xB6, 0xD8, 0xAD, 0x44, 0xD8,
+	0xB6, 0xD8, 0xAE, 0x44, 0xD8, 0xB6, 0xD8, 0xB1,
+	0x44, 0xD8, 0xB6, 0xD9, 0x85, 0x44, 0xD8, 0xB6,
+	0xD9, 0x89, 0x44, 0xD8, 0xB6, 0xD9, 0x8A, 0x44,
+	0xD8, 0xB7, 0xD8, 0xAD, 0x44, 0xD8, 0xB7, 0xD9,
+	0x85, 0x44, 0xD8, 0xB7, 0xD9, 0x89, 0x44, 0xD8,
+	0xB7, 0xD9, 0x8A, 0x44, 0xD8, 0xB8, 0xD9, 0x85,
+	// Bytes 1f00 - 1f3f
+	0x44, 0xD8, 0xB9, 0xD8, 0xAC, 0x44, 0xD8, 0xB9,
+	0xD9, 0x85, 0x44, 0xD8, 0xB9, 0xD9, 0x89, 0x44,
+	0xD8, 0xB9, 0xD9, 0x8A, 0x44, 0xD8, 0xBA, 0xD8,
+	0xAC, 0x44, 0xD8, 0xBA, 0xD9, 0x85, 0x44, 0xD8,
+	0xBA, 0xD9, 0x89, 0x44, 0xD8, 0xBA, 0xD9, 0x8A,
+	0x44, 0xD9, 0x81, 0xD8, 0xAC, 0x44, 0xD9, 0x81,
+	0xD8, 0xAD, 0x44, 0xD9, 0x81, 0xD8, 0xAE, 0x44,
+	0xD9, 0x81, 0xD9, 0x85, 0x44, 0xD9, 0x81, 0xD9,
+	// Bytes 1f40 - 1f7f
+	0x89, 0x44, 0xD9, 0x81, 0xD9, 0x8A, 0x44, 0xD9,
+	0x82, 0xD8, 0xAD, 0x44, 0xD9, 0x82, 0xD9, 0x85,
+	0x44, 0xD9, 0x82, 0xD9, 0x89, 0x44, 0xD9, 0x82,
+	0xD9, 0x8A, 0x44, 0xD9, 0x83, 0xD8, 0xA7, 0x44,
+	0xD9, 0x83, 0xD8, 0xAC, 0x44, 0xD9, 0x83, 0xD8,
+	0xAD, 0x44, 0xD9, 0x83, 0xD8, 0xAE, 0x44, 0xD9,
+	0x83, 0xD9, 0x84, 0x44, 0xD9, 0x83, 0xD9, 0x85,
+	0x44, 0xD9, 0x83, 0xD9, 0x89, 0x44, 0xD9, 0x83,
+	// Bytes 1f80 - 1fbf
+	0xD9, 0x8A, 0x44, 0xD9, 0x84, 0xD8, 0xA7, 0x44,
+	0xD9, 0x84, 0xD8, 0xAC, 0x44, 0xD9, 0x84, 0xD8,
+	0xAD, 0x44, 0xD9, 0x84, 0xD8, 0xAE, 0x44, 0xD9,
+	0x84, 0xD9, 0x85, 0x44, 0xD9, 0x84, 0xD9, 0x87,
+	0x44, 0xD9, 0x84, 0xD9, 0x89, 0x44, 0xD9, 0x84,
+	0xD9, 0x8A, 0x44, 0xD9, 0x85, 0xD8, 0xA7, 0x44,
+	0xD9, 0x85, 0xD8, 0xAC, 0x44, 0xD9, 0x85, 0xD8,
+	0xAD, 0x44, 0xD9, 0x85, 0xD8, 0xAE, 0x44, 0xD9,
+	// Bytes 1fc0 - 1fff
+	0x85, 0xD9, 0x85, 0x44, 0xD9, 0x85, 0xD9, 0x89,
+	0x44, 0xD9, 0x85, 0xD9, 0x8A, 0x44, 0xD9, 0x86,
+	0xD8, 0xAC, 0x44, 0xD9, 0x86, 0xD8, 0xAD, 0x44,
+	0xD9, 0x86, 0xD8, 0xAE, 0x44, 0xD9, 0x86, 0xD8,
+	0xB1, 0x44, 0xD9, 0x86, 0xD8, 0xB2, 0x44, 0xD9,
+	0x86, 0xD9, 0x85, 0x44, 0xD9, 0x86, 0xD9, 0x86,
+	0x44, 0xD9, 0x86, 0xD9, 0x87, 0x44, 0xD9, 0x86,
+	0xD9, 0x89, 0x44, 0xD9, 0x86, 0xD9, 0x8A, 0x44,
+	// Bytes 2000 - 203f
+	0xD9, 0x87, 0xD8, 0xAC, 0x44, 0xD9, 0x87, 0xD9,
+	0x85, 0x44, 0xD9, 0x87, 0xD9, 0x89, 0x44, 0xD9,
+	0x87, 0xD9, 0x8A, 0x44, 0xD9, 0x88, 0xD9, 0xB4,
+	0x44, 0xD9, 0x8A, 0xD8, 0xAC, 0x44, 0xD9, 0x8A,
+	0xD8, 0xAD, 0x44, 0xD9, 0x8A, 0xD8, 0xAE, 0x44,
+	0xD9, 0x8A, 0xD8, 0xB1, 0x44, 0xD9, 0x8A, 0xD8,
+	0xB2, 0x44, 0xD9, 0x8A, 0xD9, 0x85, 0x44, 0xD9,
+	0x8A, 0xD9, 0x86, 0x44, 0xD9, 0x8A, 0xD9, 0x87,
+	// Bytes 2040 - 207f
+	0x44, 0xD9, 0x8A, 0xD9, 0x89, 0x44, 0xD9, 0x8A,
+	0xD9, 0x8A, 0x44, 0xD9, 0x8A, 0xD9, 0xB4, 0x44,
+	0xDB, 0x87, 0xD9, 0xB4, 0x45, 0x28, 0xE1, 0x84,
+	0x80, 0x29, 0x45, 0x28, 0xE1, 0x84, 0x82, 0x29,
+	0x45, 0x28, 0xE1, 0x84, 0x83, 0x29, 0x45, 0x28,
+	0xE1, 0x84, 0x85, 0x29, 0x45, 0x28, 0xE1, 0x84,
+	0x86, 0x29, 0x45, 0x28, 0xE1, 0x84, 0x87, 0x29,
+	0x45, 0x28, 0xE1, 0x84, 0x89, 0x29, 0x45, 0x28,
+	// Bytes 2080 - 20bf
+	0xE1, 0x84, 0x8B, 0x29, 0x45, 0x28, 0xE1, 0x84,
+	0x8C, 0x29, 0x45, 0x28, 0xE1, 0x84, 0x8E, 0x29,
+	0x45, 0x28, 0xE1, 0x84, 0x8F, 0x29, 0x45, 0x28,
+	0xE1, 0x84, 0x90, 0x29, 0x45, 0x28, 0xE1, 0x84,
+	0x91, 0x29, 0x45, 0x28, 0xE1, 0x84, 0x92, 0x29,
+	0x45, 0x28, 0xE4, 0xB8, 0x80, 0x29, 0x45, 0x28,
+	0xE4, 0xB8, 0x83, 0x29, 0x45, 0x28, 0xE4, 0xB8,
+	0x89, 0x29, 0x45, 0x28, 0xE4, 0xB9, 0x9D, 0x29,
+	// Bytes 20c0 - 20ff
+	0x45, 0x28, 0xE4, 0xBA, 0x8C, 0x29, 0x45, 0x28,
+	0xE4, 0xBA, 0x94, 0x29, 0x45, 0x28, 0xE4, 0xBB,
+	0xA3, 0x29, 0x45, 0x28, 0xE4, 0xBC, 0x81, 0x29,
+	0x45, 0x28, 0xE4, 0xBC, 0x91, 0x29, 0x45, 0x28,
+	0xE5, 0x85, 0xAB, 0x29, 0x45, 0x28, 0xE5, 0x85,
+	0xAD, 0x29, 0x45, 0x28, 0xE5, 0x8A, 0xB4, 0x29,
+	0x45, 0x28, 0xE5, 0x8D, 0x81, 0x29, 0x45, 0x28,
+	0xE5, 0x8D, 0x94, 0x29, 0x45, 0x28, 0xE5, 0x90,
+	// Bytes 2100 - 213f
+	0x8D, 0x29, 0x45, 0x28, 0xE5, 0x91, 0xBC, 0x29,
+	0x45, 0x28, 0xE5, 0x9B, 0x9B, 0x29, 0x45, 0x28,
+	0xE5, 0x9C, 0x9F, 0x29, 0x45, 0x28, 0xE5, 0xAD,
+	0xA6, 0x29, 0x45, 0x28, 0xE6, 0x97, 0xA5, 0x29,
+	0x45, 0x28, 0xE6, 0x9C, 0x88, 0x29, 0x45, 0x28,
+	0xE6, 0x9C, 0x89, 0x29, 0x45, 0x28, 0xE6, 0x9C,
+	0xA8, 0x29, 0x45, 0x28, 0xE6, 0xA0, 0xAA, 0x29,
+	0x45, 0x28, 0xE6, 0xB0, 0xB4, 0x29, 0x45, 0x28,
+	// Bytes 2140 - 217f
+	0xE7, 0x81, 0xAB, 0x29, 0x45, 0x28, 0xE7, 0x89,
+	0xB9, 0x29, 0x45, 0x28, 0xE7, 0x9B, 0xA3, 0x29,
+	0x45, 0x28, 0xE7, 0xA4, 0xBE, 0x29, 0x45, 0x28,
+	0xE7, 0xA5, 0x9D, 0x29, 0x45, 0x28, 0xE7, 0xA5,
+	0xAD, 0x29, 0x45, 0x28, 0xE8, 0x87, 0xAA, 0x29,
+	0x45, 0x28, 0xE8, 0x87, 0xB3, 0x29, 0x45, 0x28,
+	0xE8, 0xB2, 0xA1, 0x29, 0x45, 0x28, 0xE8, 0xB3,
+	0x87, 0x29, 0x45, 0x28, 0xE9, 0x87, 0x91, 0x29,
+	// Bytes 2180 - 21bf
+	0x45, 0x30, 0xE2, 0x81, 0x84, 0x33, 0x45, 0x31,
+	0x30, 0xE6, 0x97, 0xA5, 0x45, 0x31, 0x30, 0xE6,
+	0x9C, 0x88, 0x45, 0x31, 0x30, 0xE7, 0x82, 0xB9,
+	0x45, 0x31, 0x31, 0xE6, 0x97, 0xA5, 0x45, 0x31,
+	0x31, 0xE6, 0x9C, 0x88, 0x45, 0x31, 0x31, 0xE7,
+	0x82, 0xB9, 0x45, 0x31, 0x32, 0xE6, 0x97, 0xA5,
+	0x45, 0x31, 0x32, 0xE6, 0x9C, 0x88, 0x45, 0x31,
+	0x32, 0xE7, 0x82, 0xB9, 0x45, 0x31, 0x33, 0xE6,
+	// Bytes 21c0 - 21ff
+	0x97, 0xA5, 0x45, 0x31, 0x33, 0xE7, 0x82, 0xB9,
+	0x45, 0x31, 0x34, 0xE6, 0x97, 0xA5, 0x45, 0x31,
+	0x34, 0xE7, 0x82, 0xB9, 0x45, 0x31, 0x35, 0xE6,
+	0x97, 0xA5, 0x45, 0x31, 0x35, 0xE7, 0x82, 0xB9,
+	0x45, 0x31, 0x36, 0xE6, 0x97, 0xA5, 0x45, 0x31,
+	0x36, 0xE7, 0x82, 0xB9, 0x45, 0x31, 0x37, 0xE6,
+	0x97, 0xA5, 0x45, 0x31, 0x37, 0xE7, 0x82, 0xB9,
+	0x45, 0x31, 0x38, 0xE6, 0x97, 0xA5, 0x45, 0x31,
+	// Bytes 2200 - 223f
+	0x38, 0xE7, 0x82, 0xB9, 0x45, 0x31, 0x39, 0xE6,
+	0x97, 0xA5, 0x45, 0x31, 0x39, 0xE7, 0x82, 0xB9,
+	0x45, 0x31, 0xE2, 0x81, 0x84, 0x32, 0x45, 0x31,
+	0xE2, 0x81, 0x84, 0x33, 0x45, 0x31, 0xE2, 0x81,
+	0x84, 0x34, 0x45, 0x31, 0xE2, 0x81, 0x84, 0x35,
+	0x45, 0x31, 0xE2, 0x81, 0x84, 0x36, 0x45, 0x31,
+	0xE2, 0x81, 0x84, 0x37, 0x45, 0x31, 0xE2, 0x81,
+	0x84, 0x38, 0x45, 0x31, 0xE2, 0x81, 0x84, 0x39,
+	// Bytes 2240 - 227f
+	0x45, 0x32, 0x30, 0xE6, 0x97, 0xA5, 0x45, 0x32,
+	0x30, 0xE7, 0x82, 0xB9, 0x45, 0x32, 0x31, 0xE6,
+	0x97, 0xA5, 0x45, 0x32, 0x31, 0xE7, 0x82, 0xB9,
+	0x45, 0x32, 0x32, 0xE6, 0x97, 0xA5, 0x45, 0x32,
+	0x32, 0xE7, 0x82, 0xB9, 0x45, 0x32, 0x33, 0xE6,
+	0x97, 0xA5, 0x45, 0x32, 0x33, 0xE7, 0x82, 0xB9,
+	0x45, 0x32, 0x34, 0xE6, 0x97, 0xA5, 0x45, 0x32,
+	0x34, 0xE7, 0x82, 0xB9, 0x45, 0x32, 0x35, 0xE6,
+	// Bytes 2280 - 22bf
+	0x97, 0xA5, 0x45, 0x32, 0x36, 0xE6, 0x97, 0xA5,
+	0x45, 0x32, 0x37, 0xE6, 0x97, 0xA5, 0x45, 0x32,
+	0x38, 0xE6, 0x97, 0xA5, 0x45, 0x32, 0x39, 0xE6,
+	0x97, 0xA5, 0x45, 0x32, 0xE2, 0x81, 0x84, 0x33,
+	0x45, 0x32, 0xE2, 0x81, 0x84, 0x35, 0x45, 0x33,
+	0x30, 0xE6, 0x97, 0xA5, 0x45, 0x33, 0x31, 0xE6,
+	0x97, 0xA5, 0x45, 0x33, 0xE2, 0x81, 0x84, 0x34,
+	0x45, 0x33, 0xE2, 0x81, 0x84, 0x35, 0x45, 0x33,
+	// Bytes 22c0 - 22ff
+	0xE2, 0x81, 0x84, 0x38, 0x45, 0x34, 0xE2, 0x81,
+	0x84, 0x35, 0x45, 0x35, 0xE2, 0x81, 0x84, 0x36,
+	0x45, 0x35, 0xE2, 0x81, 0x84, 0x38, 0x45, 0x37,
+	0xE2, 0x81, 0x84, 0x38, 0x45, 0x41, 0xE2, 0x88,
+	0x95, 0x6D, 0x45, 0x56, 0xE2, 0x88, 0x95, 0x6D,
+	0x45, 0x6D, 0xE2, 0x88, 0x95, 0x73, 0x46, 0x31,
+	0xE2, 0x81, 0x84, 0x31, 0x30, 0x46, 0x43, 0xE2,
+	0x88, 0x95, 0x6B, 0x67, 0x46, 0x6D, 0xE2, 0x88,
+	// Bytes 2300 - 233f
+	0x95, 0x73, 0x32, 0x46, 0xD8, 0xA8, 0xD8, 0xAD,
+	0xD9, 0x8A, 0x46, 0xD8, 0xA8, 0xD8, 0xAE, 0xD9,
+	0x8A, 0x46, 0xD8, 0xAA, 0xD8, 0xAC, 0xD9, 0x85,
+	0x46, 0xD8, 0xAA, 0xD8, 0xAC, 0xD9, 0x89, 0x46,
+	0xD8, 0xAA, 0xD8, 0xAC, 0xD9, 0x8A, 0x46, 0xD8,
+	0xAA, 0xD8, 0xAD, 0xD8, 0xAC, 0x46, 0xD8, 0xAA,
+	0xD8, 0xAD, 0xD9, 0x85, 0x46, 0xD8, 0xAA, 0xD8,
+	0xAE, 0xD9, 0x85, 0x46, 0xD8, 0xAA, 0xD8, 0xAE,
+	// Bytes 2340 - 237f
+	0xD9, 0x89, 0x46, 0xD8, 0xAA, 0xD8, 0xAE, 0xD9,
+	0x8A, 0x46, 0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAC,
+	0x46, 0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAD, 0x46,
+	0xD8, 0xAA, 0xD9, 0x85, 0xD8, 0xAE, 0x46, 0xD8,
+	0xAA, 0xD9, 0x85, 0xD9, 0x89, 0x46, 0xD8, 0xAA,
+	0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD8, 0xAC, 0xD8,
+	0xAD, 0xD9, 0x89, 0x46, 0xD8, 0xAC, 0xD8, 0xAD,
+	0xD9, 0x8A, 0x46, 0xD8, 0xAC, 0xD9, 0x85, 0xD8,
+	// Bytes 2380 - 23bf
+	0xAD, 0x46, 0xD8, 0xAC, 0xD9, 0x85, 0xD9, 0x89,
+	0x46, 0xD8, 0xAC, 0xD9, 0x85, 0xD9, 0x8A, 0x46,
+	0xD8, 0xAD, 0xD8, 0xAC, 0xD9, 0x8A, 0x46, 0xD8,
+	0xAD, 0xD9, 0x85, 0xD9, 0x89, 0x46, 0xD8, 0xAD,
+	0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD8, 0xB3, 0xD8,
+	0xAC, 0xD8, 0xAD, 0x46, 0xD8, 0xB3, 0xD8, 0xAC,
+	0xD9, 0x89, 0x46, 0xD8, 0xB3, 0xD8, 0xAD, 0xD8,
+	0xAC, 0x46, 0xD8, 0xB3, 0xD8, 0xAE, 0xD9, 0x89,
+	// Bytes 23c0 - 23ff
+	0x46, 0xD8, 0xB3, 0xD8, 0xAE, 0xD9, 0x8A, 0x46,
+	0xD8, 0xB3, 0xD9, 0x85, 0xD8, 0xAC, 0x46, 0xD8,
+	0xB3, 0xD9, 0x85, 0xD8, 0xAD, 0x46, 0xD8, 0xB3,
+	0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD8, 0xB4, 0xD8,
+	0xAC, 0xD9, 0x8A, 0x46, 0xD8, 0xB4, 0xD8, 0xAD,
+	0xD9, 0x85, 0x46, 0xD8, 0xB4, 0xD8, 0xAD, 0xD9,
+	0x8A, 0x46, 0xD8, 0xB4, 0xD9, 0x85, 0xD8, 0xAE,
+	0x46, 0xD8, 0xB4, 0xD9, 0x85, 0xD9, 0x85, 0x46,
+	// Bytes 2400 - 243f
+	0xD8, 0xB5, 0xD8, 0xAD, 0xD8, 0xAD, 0x46, 0xD8,
+	0xB5, 0xD8, 0xAD, 0xD9, 0x8A, 0x46, 0xD8, 0xB5,
+	0xD9, 0x84, 0xD9, 0x89, 0x46, 0xD8, 0xB5, 0xD9,
+	0x84, 0xDB, 0x92, 0x46, 0xD8, 0xB5, 0xD9, 0x85,
+	0xD9, 0x85, 0x46, 0xD8, 0xB6, 0xD8, 0xAD, 0xD9,
+	0x89, 0x46, 0xD8, 0xB6, 0xD8, 0xAD, 0xD9, 0x8A,
+	0x46, 0xD8, 0xB6, 0xD8, 0xAE, 0xD9, 0x85, 0x46,
+	0xD8, 0xB7, 0xD9, 0x85, 0xD8, 0xAD, 0x46, 0xD8,
+	// Bytes 2440 - 247f
+	0xB7, 0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD8, 0xB7,
+	0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD8, 0xB9, 0xD8,
+	0xAC, 0xD9, 0x85, 0x46, 0xD8, 0xB9, 0xD9, 0x85,
+	0xD9, 0x85, 0x46, 0xD8, 0xB9, 0xD9, 0x85, 0xD9,
+	0x89, 0x46, 0xD8, 0xB9, 0xD9, 0x85, 0xD9, 0x8A,
+	0x46, 0xD8, 0xBA, 0xD9, 0x85, 0xD9, 0x85, 0x46,
+	0xD8, 0xBA, 0xD9, 0x85, 0xD9, 0x89, 0x46, 0xD8,
+	0xBA, 0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD9, 0x81,
+	// Bytes 2480 - 24bf
+	0xD8, 0xAE, 0xD9, 0x85, 0x46, 0xD9, 0x81, 0xD9,
+	0x85, 0xD9, 0x8A, 0x46, 0xD9, 0x82, 0xD9, 0x84,
+	0xDB, 0x92, 0x46, 0xD9, 0x82, 0xD9, 0x85, 0xD8,
+	0xAD, 0x46, 0xD9, 0x82, 0xD9, 0x85, 0xD9, 0x85,
+	0x46, 0xD9, 0x82, 0xD9, 0x85, 0xD9, 0x8A, 0x46,
+	0xD9, 0x83, 0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD9,
+	0x83, 0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD9, 0x84,
+	0xD8, 0xAC, 0xD8, 0xAC, 0x46, 0xD9, 0x84, 0xD8,
+	// Bytes 24c0 - 24ff
+	0xAC, 0xD9, 0x85, 0x46, 0xD9, 0x84, 0xD8, 0xAC,
+	0xD9, 0x8A, 0x46, 0xD9, 0x84, 0xD8, 0xAD, 0xD9,
+	0x85, 0x46, 0xD9, 0x84, 0xD8, 0xAD, 0xD9, 0x89,
+	0x46, 0xD9, 0x84, 0xD8, 0xAD, 0xD9, 0x8A, 0x46,
+	0xD9, 0x84, 0xD8, 0xAE, 0xD9, 0x85, 0x46, 0xD9,
+	0x84, 0xD9, 0x85, 0xD8, 0xAD, 0x46, 0xD9, 0x84,
+	0xD9, 0x85, 0xD9, 0x8A, 0x46, 0xD9, 0x85, 0xD8,
+	0xAC, 0xD8, 0xAD, 0x46, 0xD9, 0x85, 0xD8, 0xAC,
+	// Bytes 2500 - 253f
+	0xD8, 0xAE, 0x46, 0xD9, 0x85, 0xD8, 0xAC, 0xD9,
+	0x85, 0x46, 0xD9, 0x85, 0xD8, 0xAC, 0xD9, 0x8A,
+	0x46, 0xD9, 0x85, 0xD8, 0xAD, 0xD8, 0xAC, 0x46,
+	0xD9, 0x85, 0xD8, 0xAD, 0xD9, 0x85, 0x46, 0xD9,
+	0x85, 0xD8, 0xAD, 0xD9, 0x8A, 0x46, 0xD9, 0x85,
+	0xD8, 0xAE, 0xD8, 0xAC, 0x46, 0xD9, 0x85, 0xD8,
+	0xAE, 0xD9, 0x85, 0x46, 0xD9, 0x85, 0xD8, 0xAE,
+	0xD9, 0x8A, 0x46, 0xD9, 0x85, 0xD9, 0x85, 0xD9,
+	// Bytes 2540 - 257f
+	0x8A, 0x46, 0xD9, 0x86, 0xD8, 0xAC, 0xD8, 0xAD,
+	0x46, 0xD9, 0x86, 0xD8, 0xAC, 0xD9, 0x85, 0x46,
+	0xD9, 0x86, 0xD8, 0xAC, 0xD9, 0x89, 0x46, 0xD9,
+	0x86, 0xD8, 0xAC, 0xD9, 0x8A, 0x46, 0xD9, 0x86,
+	0xD8, 0xAD, 0xD9, 0x85, 0x46, 0xD9, 0x86, 0xD8,
+	0xAD, 0xD9, 0x89, 0x46, 0xD9, 0x86, 0xD8, 0xAD,
+	0xD9, 0x8A, 0x46, 0xD9, 0x86, 0xD9, 0x85, 0xD9,
+	0x89, 0x46, 0xD9, 0x86, 0xD9, 0x85, 0xD9, 0x8A,
+	// Bytes 2580 - 25bf
+	0x46, 0xD9, 0x87, 0xD9, 0x85, 0xD8, 0xAC, 0x46,
+	0xD9, 0x87, 0xD9, 0x85, 0xD9, 0x85, 0x46, 0xD9,
+	0x8A, 0xD8, 0xAC, 0xD9, 0x8A, 0x46, 0xD9, 0x8A,
+	0xD8, 0xAD, 0xD9, 0x8A, 0x46, 0xD9, 0x8A, 0xD9,
+	0x85, 0xD9, 0x85, 0x46, 0xD9, 0x8A, 0xD9, 0x85,
+	0xD9, 0x8A, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD8,
+	0xA7, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xAC,
+	0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xAD, 0x46,
+	// Bytes 25c0 - 25ff
+	0xD9, 0x8A, 0xD9, 0x94, 0xD8, 0xAE, 0x46, 0xD9,
+	0x8A, 0xD9, 0x94, 0xD8, 0xB1, 0x46, 0xD9, 0x8A,
+	0xD9, 0x94, 0xD8, 0xB2, 0x46, 0xD9, 0x8A, 0xD9,
+	0x94, 0xD9, 0x85, 0x46, 0xD9, 0x8A, 0xD9, 0x94,
+	0xD9, 0x86, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD9,
+	0x87, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x88,
+	0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x89, 0x46,
+	0xD9, 0x8A, 0xD9, 0x94, 0xD9, 0x8A, 0x46, 0xD9,
+	// Bytes 2600 - 263f
+	0x8A, 0xD9, 0x94, 0xDB, 0x86, 0x46, 0xD9, 0x8A,
+	0xD9, 0x94, 0xDB, 0x87, 0x46, 0xD9, 0x8A, 0xD9,
+	0x94, 0xDB, 0x88, 0x46, 0xD9, 0x8A, 0xD9, 0x94,
+	0xDB, 0x90, 0x46, 0xD9, 0x8A, 0xD9, 0x94, 0xDB,
+	0x95, 0x46, 0xE0, 0xB9, 0x8D, 0xE0, 0xB8, 0xB2,
+	0x46, 0xE0, 0xBA, 0xAB, 0xE0, 0xBA, 0x99, 0x46,
+	0xE0, 0xBA, 0xAB, 0xE0, 0xBA, 0xA1, 0x46, 0xE0,
+	0xBB, 0x8D, 0xE0, 0xBA, 0xB2, 0x46, 0xE0, 0xBD,
+	// Bytes 2640 - 267f
+	0x80, 0xE0, 0xBE, 0xB5, 0x46, 0xE0, 0xBD, 0x82,
+	0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBD, 0x8C, 0xE0,
+	0xBE, 0xB7, 0x46, 0xE0, 0xBD, 0x91, 0xE0, 0xBE,
+	0xB7, 0x46, 0xE0, 0xBD, 0x96, 0xE0, 0xBE, 0xB7,
+	0x46, 0xE0, 0xBD, 0x9B, 0xE0, 0xBE, 0xB7, 0x46,
+	0xE0, 0xBE, 0x90, 0xE0, 0xBE, 0xB5, 0x46, 0xE0,
+	0xBE, 0x92, 0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBE,
+	0x9C, 0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBE, 0xA1,
+	// Bytes 2680 - 26bf
+	0xE0, 0xBE, 0xB7, 0x46, 0xE0, 0xBE, 0xA6, 0xE0,
+	0xBE, 0xB7, 0x46, 0xE0, 0xBE, 0xAB, 0xE0, 0xBE,
+	0xB7, 0x46, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2,
+	0x46, 0xE2, 0x80, 0xB5, 0xE2, 0x80, 0xB5, 0x46,
+	0xE2, 0x88, 0xAB, 0xE2, 0x88, 0xAB, 0x46, 0xE2,
+	0x88, 0xAE, 0xE2, 0x88, 0xAE, 0x46, 0xE3, 0x81,
+	0xBB, 0xE3, 0x81, 0x8B, 0x46, 0xE3, 0x82, 0x88,
+	0xE3, 0x82, 0x8A, 0x46, 0xE3, 0x82, 0xAD, 0xE3,
+	// Bytes 26c0 - 26ff
+	0x83, 0xAD, 0x46, 0xE3, 0x82, 0xB3, 0xE3, 0x82,
+	0xB3, 0x46, 0xE3, 0x82, 0xB3, 0xE3, 0x83, 0x88,
+	0x46, 0xE3, 0x83, 0x88, 0xE3, 0x83, 0xB3, 0x46,
+	0xE3, 0x83, 0x8A, 0xE3, 0x83, 0x8E, 0x46, 0xE3,
+	0x83, 0x9B, 0xE3, 0x83, 0xB3, 0x46, 0xE3, 0x83,
+	0x9F, 0xE3, 0x83, 0xAA, 0x46, 0xE3, 0x83, 0xAA,
+	0xE3, 0x83, 0xA9, 0x46, 0xE3, 0x83, 0xAC, 0xE3,
+	0x83, 0xA0, 0x46, 0xE5, 0xA4, 0xA7, 0xE6, 0xAD,
+	// Bytes 2700 - 273f
+	0xA3, 0x46, 0xE5, 0xB9, 0xB3, 0xE6, 0x88, 0x90,
+	0x46, 0xE6, 0x98, 0x8E, 0xE6, 0xB2, 0xBB, 0x46,
+	0xE6, 0x98, 0xAD, 0xE5, 0x92, 0x8C, 0x47, 0x72,
+	0x61, 0x64, 0xE2, 0x88, 0x95, 0x73, 0x47, 0xE3,
+	0x80, 0x94, 0x53, 0xE3, 0x80, 0x95, 0x48, 0x28,
+	0xE1, 0x84, 0x80, 0xE1, 0x85, 0xA1, 0x29, 0x48,
+	0x28, 0xE1, 0x84, 0x82, 0xE1, 0x85, 0xA1, 0x29,
+	0x48, 0x28, 0xE1, 0x84, 0x83, 0xE1, 0x85, 0xA1,
+	// Bytes 2740 - 277f
+	0x29, 0x48, 0x28, 0xE1, 0x84, 0x85, 0xE1, 0x85,
+	0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x86, 0xE1,
+	0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x87,
+	0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84,
+	0x89, 0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1,
+	0x84, 0x8B, 0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28,
+	0xE1, 0x84, 0x8C, 0xE1, 0x85, 0xA1, 0x29, 0x48,
+	0x28, 0xE1, 0x84, 0x8C, 0xE1, 0x85, 0xAE, 0x29,
+	// Bytes 2780 - 27bf
+	0x48, 0x28, 0xE1, 0x84, 0x8E, 0xE1, 0x85, 0xA1,
+	0x29, 0x48, 0x28, 0xE1, 0x84, 0x8F, 0xE1, 0x85,
+	0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x90, 0xE1,
+	0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84, 0x91,
+	0xE1, 0x85, 0xA1, 0x29, 0x48, 0x28, 0xE1, 0x84,
+	0x92, 0xE1, 0x85, 0xA1, 0x29, 0x48, 0x72, 0x61,
+	0x64, 0xE2, 0x88, 0x95, 0x73, 0x32, 0x48, 0xD8,
+	0xA7, 0xD9, 0x83, 0xD8, 0xA8, 0xD8, 0xB1, 0x48,
+	// Bytes 27c0 - 27ff
+	0xD8, 0xA7, 0xD9, 0x84, 0xD9, 0x84, 0xD9, 0x87,
+	0x48, 0xD8, 0xB1, 0xD8, 0xB3, 0xD9, 0x88, 0xD9,
+	0x84, 0x48, 0xD8, 0xB1, 0xDB, 0x8C, 0xD8, 0xA7,
+	0xD9, 0x84, 0x48, 0xD8, 0xB5, 0xD9, 0x84, 0xD8,
+	0xB9, 0xD9, 0x85, 0x48, 0xD8, 0xB9, 0xD9, 0x84,
+	0xD9, 0x8A, 0xD9, 0x87, 0x48, 0xD9, 0x85, 0xD8,
+	0xAD, 0xD9, 0x85, 0xD8, 0xAF, 0x48, 0xD9, 0x88,
+	0xD8, 0xB3, 0xD9, 0x84, 0xD9, 0x85, 0x49, 0xE2,
+	// Bytes 2800 - 283f
+	0x80, 0xB2, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2,
+	0x49, 0xE2, 0x80, 0xB5, 0xE2, 0x80, 0xB5, 0xE2,
+	0x80, 0xB5, 0x49, 0xE2, 0x88, 0xAB, 0xE2, 0x88,
+	0xAB, 0xE2, 0x88, 0xAB, 0x49, 0xE2, 0x88, 0xAE,
+	0xE2, 0x88, 0xAE, 0xE2, 0x88, 0xAE, 0x49, 0xE3,
+	0x80, 0x94, 0xE4, 0xB8, 0x89, 0xE3, 0x80, 0x95,
+	0x49, 0xE3, 0x80, 0x94, 0xE4, 0xBA, 0x8C, 0xE3,
+	0x80, 0x95, 0x49, 0xE3, 0x80, 0x94, 0xE5, 0x8B,
+	// Bytes 2840 - 287f
+	0x9D, 0xE3, 0x80, 0x95, 0x49, 0xE3, 0x80, 0x94,
+	0xE5, 0xAE, 0x89, 0xE3, 0x80, 0x95, 0x49, 0xE3,
+	0x80, 0x94, 0xE6, 0x89, 0x93, 0xE3, 0x80, 0x95,
+	0x49, 0xE3, 0x80, 0x94, 0xE6, 0x95, 0x97, 0xE3,
+	0x80, 0x95, 0x49, 0xE3, 0x80, 0x94, 0xE6, 0x9C,
+	0xAC, 0xE3, 0x80, 0x95, 0x49, 0xE3, 0x80, 0x94,
+	0xE7, 0x82, 0xB9, 0xE3, 0x80, 0x95, 0x49, 0xE3,
+	0x80, 0x94, 0xE7, 0x9B, 0x97, 0xE3, 0x80, 0x95,
+	// Bytes 2880 - 28bf
+	0x49, 0xE3, 0x82, 0xA2, 0xE3, 0x83, 0xBC, 0xE3,
+	0x83, 0xAB, 0x49, 0xE3, 0x82, 0xA4, 0xE3, 0x83,
+	0xB3, 0xE3, 0x83, 0x81, 0x49, 0xE3, 0x82, 0xA6,
+	0xE3, 0x82, 0xA9, 0xE3, 0x83, 0xB3, 0x49, 0xE3,
+	0x82, 0xAA, 0xE3, 0x83, 0xB3, 0xE3, 0x82, 0xB9,
+	0x49, 0xE3, 0x82, 0xAA, 0xE3, 0x83, 0xBC, 0xE3,
+	0x83, 0xA0, 0x49, 0xE3, 0x82, 0xAB, 0xE3, 0x82,
+	0xA4, 0xE3, 0x83, 0xAA, 0x49, 0xE3, 0x82, 0xB1,
+	// Bytes 28c0 - 28ff
+	0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xB9, 0x49, 0xE3,
+	0x82, 0xB3, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x8A,
+	0x49, 0xE3, 0x82, 0xBB, 0xE3, 0x83, 0xB3, 0xE3,
+	0x83, 0x81, 0x49, 0xE3, 0x82, 0xBB, 0xE3, 0x83,
+	0xB3, 0xE3, 0x83, 0x88, 0x49, 0xE3, 0x83, 0x86,
+	0xE3, 0x82, 0x99, 0xE3, 0x82, 0xB7, 0x49, 0xE3,
+	0x83, 0x88, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xAB,
+	0x49, 0xE3, 0x83, 0x8E, 0xE3, 0x83, 0x83, 0xE3,
+	// Bytes 2900 - 293f
+	0x83, 0x88, 0x49, 0xE3, 0x83, 0x8F, 0xE3, 0x82,
+	0xA4, 0xE3, 0x83, 0x84, 0x49, 0xE3, 0x83, 0x92,
+	0xE3, 0x82, 0x99, 0xE3, 0x83, 0xAB, 0x49, 0xE3,
+	0x83, 0x92, 0xE3, 0x82, 0x9A, 0xE3, 0x82, 0xB3,
+	0x49, 0xE3, 0x83, 0x95, 0xE3, 0x83, 0xA9, 0xE3,
+	0x83, 0xB3, 0x49, 0xE3, 0x83, 0x98, 0xE3, 0x82,
+	0x9A, 0xE3, 0x82, 0xBD, 0x49, 0xE3, 0x83, 0x98,
+	0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x84, 0x49, 0xE3,
+	// Bytes 2940 - 297f
+	0x83, 0x9B, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0xAB,
+	0x49, 0xE3, 0x83, 0x9B, 0xE3, 0x83, 0xBC, 0xE3,
+	0x83, 0xB3, 0x49, 0xE3, 0x83, 0x9E, 0xE3, 0x82,
+	0xA4, 0xE3, 0x83, 0xAB, 0x49, 0xE3, 0x83, 0x9E,
+	0xE3, 0x83, 0x83, 0xE3, 0x83, 0x8F, 0x49, 0xE3,
+	0x83, 0x9E, 0xE3, 0x83, 0xAB, 0xE3, 0x82, 0xAF,
+	0x49, 0xE3, 0x83, 0xA4, 0xE3, 0x83, 0xBC, 0xE3,
+	0x83, 0xAB, 0x49, 0xE3, 0x83, 0xA6, 0xE3, 0x82,
+	// Bytes 2980 - 29bf
+	0xA2, 0xE3, 0x83, 0xB3, 0x49, 0xE3, 0x83, 0xAF,
+	0xE3, 0x83, 0x83, 0xE3, 0x83, 0x88, 0x4C, 0xE2,
+	0x80, 0xB2, 0xE2, 0x80, 0xB2, 0xE2, 0x80, 0xB2,
+	0xE2, 0x80, 0xB2, 0x4C, 0xE2, 0x88, 0xAB, 0xE2,
+	0x88, 0xAB, 0xE2, 0x88, 0xAB, 0xE2, 0x88, 0xAB,
+	0x4C, 0xE3, 0x82, 0xA2, 0xE3, 0x83, 0xAB, 0xE3,
+	0x83, 0x95, 0xE3, 0x82, 0xA1, 0x4C, 0xE3, 0x82,
+	0xA8, 0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xAB, 0xE3,
+	// Bytes 29c0 - 29ff
+	0x83, 0xBC, 0x4C, 0xE3, 0x82, 0xAB, 0xE3, 0x82,
+	0x99, 0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xB3, 0x4C,
+	0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	0xB3, 0xE3, 0x83, 0x9E, 0x4C, 0xE3, 0x82, 0xAB,
+	0xE3, 0x83, 0xA9, 0xE3, 0x83, 0x83, 0xE3, 0x83,
+	0x88, 0x4C, 0xE3, 0x82, 0xAB, 0xE3, 0x83, 0xAD,
+	0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xBC, 0x4C, 0xE3,
+	0x82, 0xAD, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0x8B,
+	// Bytes 2a00 - 2a3f
+	0xE3, 0x83, 0xBC, 0x4C, 0xE3, 0x82, 0xAD, 0xE3,
+	0x83, 0xA5, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xBC,
+	0x4C, 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0xE3,
+	0x83, 0xA9, 0xE3, 0x83, 0xA0, 0x4C, 0xE3, 0x82,
+	0xAF, 0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xBC, 0xE3,
+	0x83, 0x8D, 0x4C, 0xE3, 0x82, 0xB5, 0xE3, 0x82,
+	0xA4, 0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAB, 0x4C,
+	0xE3, 0x82, 0xBF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	// Bytes 2a40 - 2a7f
+	0xBC, 0xE3, 0x82, 0xB9, 0x4C, 0xE3, 0x83, 0x8F,
+	0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+	0x84, 0x4C, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x9A,
+	0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAB, 0x4C, 0xE3,
+	0x83, 0x95, 0xE3, 0x82, 0xA3, 0xE3, 0x83, 0xBC,
+	0xE3, 0x83, 0x88, 0x4C, 0xE3, 0x83, 0x98, 0xE3,
+	0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3, 0x82, 0xBF,
+	0x4C, 0xE3, 0x83, 0x98, 0xE3, 0x82, 0x9A, 0xE3,
+	// Bytes 2a80 - 2abf
+	0x83, 0x8B, 0xE3, 0x83, 0x92, 0x4C, 0xE3, 0x83,
+	0x98, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xB3, 0xE3,
+	0x82, 0xB9, 0x4C, 0xE3, 0x83, 0x9B, 0xE3, 0x82,
+	0x99, 0xE3, 0x83, 0xAB, 0xE3, 0x83, 0x88, 0x4C,
+	0xE3, 0x83, 0x9E, 0xE3, 0x82, 0xA4, 0xE3, 0x82,
+	0xAF, 0xE3, 0x83, 0xAD, 0x4C, 0xE3, 0x83, 0x9F,
+	0xE3, 0x82, 0xAF, 0xE3, 0x83, 0xAD, 0xE3, 0x83,
+	0xB3, 0x4C, 0xE3, 0x83, 0xA1, 0xE3, 0x83, 0xBC,
+	// Bytes 2ac0 - 2aff
+	0xE3, 0x83, 0x88, 0xE3, 0x83, 0xAB, 0x4C, 0xE3,
+	0x83, 0xAA, 0xE3, 0x83, 0x83, 0xE3, 0x83, 0x88,
+	0xE3, 0x83, 0xAB, 0x4C, 0xE3, 0x83, 0xAB, 0xE3,
+	0x83, 0x92, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC,
+	0x4C, 0xE6, 0xA0, 0xAA, 0xE5, 0xBC, 0x8F, 0xE4,
+	0xBC, 0x9A, 0xE7, 0xA4, 0xBE, 0x4E, 0x28, 0xE1,
+	0x84, 0x8B, 0xE1, 0x85, 0xA9, 0xE1, 0x84, 0x92,
+	0xE1, 0x85, 0xAE, 0x29, 0x4F, 0xD8, 0xAC, 0xD9,
+	// Bytes 2b00 - 2b3f
+	0x84, 0x20, 0xD8, 0xAC, 0xD9, 0x84, 0xD8, 0xA7,
+	0xD9, 0x84, 0xD9, 0x87, 0x4F, 0xE3, 0x82, 0xA2,
+	0xE3, 0x83, 0x8F, 0xE3, 0x82, 0x9A, 0xE3, 0x83,
+	0xBC, 0xE3, 0x83, 0x88, 0x4F, 0xE3, 0x82, 0xA2,
+	0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x98, 0xE3, 0x82,
+	0x9A, 0xE3, 0x82, 0xA2, 0x4F, 0xE3, 0x82, 0xAD,
+	0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xAF, 0xE3, 0x83,
+	0x83, 0xE3, 0x83, 0x88, 0x4F, 0xE3, 0x82, 0xB5,
+	// Bytes 2b40 - 2b7f
+	0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x81, 0xE3, 0x83,
+	0xBC, 0xE3, 0x83, 0xA0, 0x4F, 0xE3, 0x83, 0x8F,
+	0xE3, 0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+	0xAC, 0xE3, 0x83, 0xAB, 0x4F, 0xE3, 0x83, 0x98,
+	0xE3, 0x82, 0xAF, 0xE3, 0x82, 0xBF, 0xE3, 0x83,
+	0xBC, 0xE3, 0x83, 0xAB, 0x4F, 0xE3, 0x83, 0x9B,
+	0xE3, 0x82, 0x9A, 0xE3, 0x82, 0xA4, 0xE3, 0x83,
+	0xB3, 0xE3, 0x83, 0x88, 0x4F, 0xE3, 0x83, 0x9E,
+	// Bytes 2b80 - 2bbf
+	0xE3, 0x83, 0xB3, 0xE3, 0x82, 0xB7, 0xE3, 0x83,
+	0xA7, 0xE3, 0x83, 0xB3, 0x4F, 0xE3, 0x83, 0xA1,
+	0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	0x88, 0xE3, 0x83, 0xB3, 0x4F, 0xE3, 0x83, 0xAB,
+	0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x95, 0xE3, 0x82,
+	0x99, 0xE3, 0x83, 0xAB, 0x51, 0x28, 0xE1, 0x84,
+	0x8B, 0xE1, 0x85, 0xA9, 0xE1, 0x84, 0x8C, 0xE1,
+	0x85, 0xA5, 0xE1, 0x86, 0xAB, 0x29, 0x52, 0xE3,
+	// Bytes 2bc0 - 2bff
+	0x82, 0xAD, 0xE3, 0x82, 0x99, 0xE3, 0x83, 0xAB,
+	0xE3, 0x82, 0xBF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	0xBC, 0x52, 0xE3, 0x82, 0xAD, 0xE3, 0x83, 0xAD,
+	0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	0xA9, 0xE3, 0x83, 0xA0, 0x52, 0xE3, 0x82, 0xAD,
+	0xE3, 0x83, 0xAD, 0xE3, 0x83, 0xA1, 0xE3, 0x83,
+	0xBC, 0xE3, 0x83, 0x88, 0xE3, 0x83, 0xAB, 0x52,
+	0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0xE3, 0x83,
+	// Bytes 2c00 - 2c3f
+	0xA9, 0xE3, 0x83, 0xA0, 0xE3, 0x83, 0x88, 0xE3,
+	0x83, 0xB3, 0x52, 0xE3, 0x82, 0xAF, 0xE3, 0x83,
+	0xAB, 0xE3, 0x82, 0xBB, 0xE3, 0x82, 0x99, 0xE3,
+	0x82, 0xA4, 0xE3, 0x83, 0xAD, 0x52, 0xE3, 0x83,
+	0x8F, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC, 0xE3,
+	0x82, 0xBB, 0xE3, 0x83, 0xB3, 0xE3, 0x83, 0x88,
+	0x52, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x9A, 0xE3,
+	0x82, 0xA2, 0xE3, 0x82, 0xB9, 0xE3, 0x83, 0x88,
+	// Bytes 2c40 - 2c7f
+	0xE3, 0x83, 0xAB, 0x52, 0xE3, 0x83, 0x95, 0xE3,
+	0x82, 0x99, 0xE3, 0x83, 0x83, 0xE3, 0x82, 0xB7,
+	0xE3, 0x82, 0xA7, 0xE3, 0x83, 0xAB, 0x52, 0xE3,
+	0x83, 0x9F, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0x8F,
+	0xE3, 0x82, 0x99, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+	0xAB, 0x52, 0xE3, 0x83, 0xAC, 0xE3, 0x83, 0xB3,
+	0xE3, 0x83, 0x88, 0xE3, 0x82, 0xB1, 0xE3, 0x82,
+	0x99, 0xE3, 0x83, 0xB3, 0x61, 0xD8, 0xB5, 0xD9,
+	// Bytes 2c80 - 2cbf
+	0x84, 0xD9, 0x89, 0x20, 0xD8, 0xA7, 0xD9, 0x84,
+	0xD9, 0x84, 0xD9, 0x87, 0x20, 0xD8, 0xB9, 0xD9,
+	0x84, 0xD9, 0x8A, 0xD9, 0x87, 0x20, 0xD9, 0x88,
+	0xD8, 0xB3, 0xD9, 0x84, 0xD9, 0x85, 0x06, 0xE0,
+	0xA7, 0x87, 0xE0, 0xA6, 0xBE, 0x01, 0x06, 0xE0,
+	0xA7, 0x87, 0xE0, 0xA7, 0x97, 0x01, 0x06, 0xE0,
+	0xAD, 0x87, 0xE0, 0xAC, 0xBE, 0x01, 0x06, 0xE0,
+	0xAD, 0x87, 0xE0, 0xAD, 0x96, 0x01, 0x06, 0xE0,
+	// Bytes 2cc0 - 2cff
+	0xAD, 0x87, 0xE0, 0xAD, 0x97, 0x01, 0x06, 0xE0,
+	0xAE, 0x92, 0xE0, 0xAF, 0x97, 0x01, 0x06, 0xE0,
+	0xAF, 0x86, 0xE0, 0xAE, 0xBE, 0x01, 0x06, 0xE0,
+	0xAF, 0x86, 0xE0, 0xAF, 0x97, 0x01, 0x06, 0xE0,
+	0xAF, 0x87, 0xE0, 0xAE, 0xBE, 0x01, 0x06, 0xE0,
+	0xB2, 0xBF, 0xE0, 0xB3, 0x95, 0x01, 0x06, 0xE0,
+	0xB3, 0x86, 0xE0, 0xB3, 0x95, 0x01, 0x06, 0xE0,
+	0xB3, 0x86, 0xE0, 0xB3, 0x96, 0x01, 0x06, 0xE0,
+	// Bytes 2d00 - 2d3f
+	0xB5, 0x86, 0xE0, 0xB4, 0xBE, 0x01, 0x06, 0xE0,
+	0xB5, 0x86, 0xE0, 0xB5, 0x97, 0x01, 0x06, 0xE0,
+	0xB5, 0x87, 0xE0, 0xB4, 0xBE, 0x01, 0x06, 0xE0,
+	0xB7, 0x99, 0xE0, 0xB7, 0x9F, 0x01, 0x06, 0xE1,
+	0x80, 0xA5, 0xE1, 0x80, 0xAE, 0x01, 0x06, 0xE1,
+	0xAC, 0x85, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0x87, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0x89, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	// Bytes 2d40 - 2d7f
+	0xAC, 0x8B, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0x8D, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0x91, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0xBA, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0xBC, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0xBE, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAC, 0xBF, 0xE1, 0xAC, 0xB5, 0x01, 0x06, 0xE1,
+	0xAD, 0x82, 0xE1, 0xAC, 0xB5, 0x01, 0x08, 0xF0,
+	// Bytes 2d80 - 2dbf
+	0x91, 0x84, 0xB1, 0xF0, 0x91, 0x84, 0xA7, 0x01,
+	0x08, 0xF0, 0x91, 0x84, 0xB2, 0xF0, 0x91, 0x84,
+	0xA7, 0x01, 0x08, 0xF0, 0x91, 0x8D, 0x87, 0xF0,
+	0x91, 0x8C, 0xBE, 0x01, 0x08, 0xF0, 0x91, 0x8D,
+	0x87, 0xF0, 0x91, 0x8D, 0x97, 0x01, 0x08, 0xF0,
+	0x91, 0x92, 0xB9, 0xF0, 0x91, 0x92, 0xB0, 0x01,
+	0x08, 0xF0, 0x91, 0x92, 0xB9, 0xF0, 0x91, 0x92,
+	0xBA, 0x01, 0x08, 0xF0, 0x91, 0x92, 0xB9, 0xF0,
+	// Bytes 2dc0 - 2dff
+	0x91, 0x92, 0xBD, 0x01, 0x08, 0xF0, 0x91, 0x96,
+	0xB8, 0xF0, 0x91, 0x96, 0xAF, 0x01, 0x08, 0xF0,
+	0x91, 0x96, 0xB9, 0xF0, 0x91, 0x96, 0xAF, 0x01,
+	0x09, 0xE0, 0xB3, 0x86, 0xE0, 0xB3, 0x82, 0xE0,
+	0xB3, 0x95, 0x02, 0x09, 0xE0, 0xB7, 0x99, 0xE0,
+	0xB7, 0x8F, 0xE0, 0xB7, 0x8A, 0x12, 0x44, 0x44,
+	0x5A, 0xCC, 0x8C, 0xC9, 0x44, 0x44, 0x7A, 0xCC,
+	0x8C, 0xC9, 0x44, 0x64, 0x7A, 0xCC, 0x8C, 0xC9,
+	// Bytes 2e00 - 2e3f
+	0x46, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x93, 0xC9,
+	0x46, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x94, 0xC9,
+	0x46, 0xD9, 0x84, 0xD8, 0xA7, 0xD9, 0x95, 0xB5,
+	0x46, 0xE1, 0x84, 0x80, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x82, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x83, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x85, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x86, 0xE1, 0x85, 0xA1, 0x01,
+	// Bytes 2e40 - 2e7f
+	0x46, 0xE1, 0x84, 0x87, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x89, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x8B, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x8B, 0xE1, 0x85, 0xAE, 0x01,
+	0x46, 0xE1, 0x84, 0x8C, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x8E, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x8F, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x90, 0xE1, 0x85, 0xA1, 0x01,
+	// Bytes 2e80 - 2ebf
+	0x46, 0xE1, 0x84, 0x91, 0xE1, 0x85, 0xA1, 0x01,
+	0x46, 0xE1, 0x84, 0x92, 0xE1, 0x85, 0xA1, 0x01,
+	0x49, 0xE3, 0x83, 0xA1, 0xE3, 0x82, 0xAB, 0xE3,
+	0x82, 0x99, 0x0D, 0x4C, 0xE1, 0x84, 0x8C, 0xE1,
+	0x85, 0xAE, 0xE1, 0x84, 0x8B, 0xE1, 0x85, 0xB4,
+	0x01, 0x4C, 0xE3, 0x82, 0xAD, 0xE3, 0x82, 0x99,
+	0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0x0D, 0x4C,
+	0xE3, 0x82, 0xB3, 0xE3, 0x83, 0xBC, 0xE3, 0x83,
+	// Bytes 2ec0 - 2eff
+	0x9B, 0xE3, 0x82, 0x9A, 0x0D, 0x4C, 0xE3, 0x83,
+	0xA4, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x88, 0xE3,
+	0x82, 0x99, 0x0D, 0x4F, 0xE1, 0x84, 0x8E, 0xE1,
+	0x85, 0xA1, 0xE1, 0x86, 0xB7, 0xE1, 0x84, 0x80,
+	0xE1, 0x85, 0xA9, 0x01, 0x4F, 0xE3, 0x82, 0xA4,
+	0xE3, 0x83, 0x8B, 0xE3, 0x83, 0xB3, 0xE3, 0x82,
+	0xAF, 0xE3, 0x82, 0x99, 0x0D, 0x4F, 0xE3, 0x82,
+	0xB7, 0xE3, 0x83, 0xAA, 0xE3, 0x83, 0xB3, 0xE3,
+	// Bytes 2f00 - 2f3f
+	0x82, 0xAF, 0xE3, 0x82, 0x99, 0x0D, 0x4F, 0xE3,
+	0x83, 0x98, 0xE3, 0x82, 0x9A, 0xE3, 0x83, 0xBC,
+	0xE3, 0x82, 0xB7, 0xE3, 0x82, 0x99, 0x0D, 0x4F,
+	0xE3, 0x83, 0x9B, 0xE3, 0x82, 0x9A, 0xE3, 0x83,
+	0xB3, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0x99, 0x0D,
+	0x52, 0xE3, 0x82, 0xA8, 0xE3, 0x82, 0xB9, 0xE3,
+	0x82, 0xAF, 0xE3, 0x83, 0xBC, 0xE3, 0x83, 0x88,
+	0xE3, 0x82, 0x99, 0x0D, 0x52, 0xE3, 0x83, 0x95,
+	// Bytes 2f40 - 2f7f
+	0xE3, 0x82, 0xA1, 0xE3, 0x83, 0xA9, 0xE3, 0x83,
+	0x83, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0x99, 0x0D,
+	0x86, 0xE0, 0xB3, 0x86, 0xE0, 0xB3, 0x82, 0x01,
+	0x86, 0xE0, 0xB7, 0x99, 0xE0, 0xB7, 0x8F, 0x01,
+	0x03, 0x3C, 0xCC, 0xB8, 0x05, 0x03, 0x3D, 0xCC,
+	0xB8, 0x05, 0x03, 0x3E, 0xCC, 0xB8, 0x05, 0x03,
+	0x41, 0xCC, 0x80, 0xC9, 0x03, 0x41, 0xCC, 0x81,
+	0xC9, 0x03, 0x41, 0xCC, 0x83, 0xC9, 0x03, 0x41,
+	// Bytes 2f80 - 2fbf
+	0xCC, 0x84, 0xC9, 0x03, 0x41, 0xCC, 0x89, 0xC9,
+	0x03, 0x41, 0xCC, 0x8C, 0xC9, 0x03, 0x41, 0xCC,
+	0x8F, 0xC9, 0x03, 0x41, 0xCC, 0x91, 0xC9, 0x03,
+	0x41, 0xCC, 0xA5, 0xB5, 0x03, 0x41, 0xCC, 0xA8,
+	0xA5, 0x03, 0x42, 0xCC, 0x87, 0xC9, 0x03, 0x42,
+	0xCC, 0xA3, 0xB5, 0x03, 0x42, 0xCC, 0xB1, 0xB5,
+	0x03, 0x43, 0xCC, 0x81, 0xC9, 0x03, 0x43, 0xCC,
+	0x82, 0xC9, 0x03, 0x43, 0xCC, 0x87, 0xC9, 0x03,
+	// Bytes 2fc0 - 2fff
+	0x43, 0xCC, 0x8C, 0xC9, 0x03, 0x44, 0xCC, 0x87,
+	0xC9, 0x03, 0x44, 0xCC, 0x8C, 0xC9, 0x03, 0x44,
+	0xCC, 0xA3, 0xB5, 0x03, 0x44, 0xCC, 0xA7, 0xA5,
+	0x03, 0x44, 0xCC, 0xAD, 0xB5, 0x03, 0x44, 0xCC,
+	0xB1, 0xB5, 0x03, 0x45, 0xCC, 0x80, 0xC9, 0x03,
+	0x45, 0xCC, 0x81, 0xC9, 0x03, 0x45, 0xCC, 0x83,
+	0xC9, 0x03, 0x45, 0xCC, 0x86, 0xC9, 0x03, 0x45,
+	0xCC, 0x87, 0xC9, 0x03, 0x45, 0xCC, 0x88, 0xC9,
+	// Bytes 3000 - 303f
+	0x03, 0x45, 0xCC, 0x89, 0xC9, 0x03, 0x45, 0xCC,
+	0x8C, 0xC9, 0x03, 0x45, 0xCC, 0x8F, 0xC9, 0x03,
+	0x45, 0xCC, 0x91, 0xC9, 0x03, 0x45, 0xCC, 0xA8,
+	0xA5, 0x03, 0x45, 0xCC, 0xAD, 0xB5, 0x03, 0x45,
+	0xCC, 0xB0, 0xB5, 0x03, 0x46, 0xCC, 0x87, 0xC9,
+	0x03, 0x47, 0xCC, 0x81, 0xC9, 0x03, 0x47, 0xCC,
+	0x82, 0xC9, 0x03, 0x47, 0xCC, 0x84, 0xC9, 0x03,
+	0x47, 0xCC, 0x86, 0xC9, 0x03, 0x47, 0xCC, 0x87,
+	// Bytes 3040 - 307f
+	0xC9, 0x03, 0x47, 0xCC, 0x8C, 0xC9, 0x03, 0x47,
+	0xCC, 0xA7, 0xA5, 0x03, 0x48, 0xCC, 0x82, 0xC9,
+	0x03, 0x48, 0xCC, 0x87, 0xC9, 0x03, 0x48, 0xCC,
+	0x88, 0xC9, 0x03, 0x48, 0xCC, 0x8C, 0xC9, 0x03,
+	0x48, 0xCC, 0xA3, 0xB5, 0x03, 0x48, 0xCC, 0xA7,
+	0xA5, 0x03, 0x48, 0xCC, 0xAE, 0xB5, 0x03, 0x49,
+	0xCC, 0x80, 0xC9, 0x03, 0x49, 0xCC, 0x81, 0xC9,
+	0x03, 0x49, 0xCC, 0x82, 0xC9, 0x03, 0x49, 0xCC,
+	// Bytes 3080 - 30bf
+	0x83, 0xC9, 0x03, 0x49, 0xCC, 0x84, 0xC9, 0x03,
+	0x49, 0xCC, 0x86, 0xC9, 0x03, 0x49, 0xCC, 0x87,
+	0xC9, 0x03, 0x49, 0xCC, 0x89, 0xC9, 0x03, 0x49,
+	0xCC, 0x8C, 0xC9, 0x03, 0x49, 0xCC, 0x8F, 0xC9,
+	0x03, 0x49, 0xCC, 0x91, 0xC9, 0x03, 0x49, 0xCC,
+	0xA3, 0xB5, 0x03, 0x49, 0xCC, 0xA8, 0xA5, 0x03,
+	0x49, 0xCC, 0xB0, 0xB5, 0x03, 0x4A, 0xCC, 0x82,
+	0xC9, 0x03, 0x4B, 0xCC, 0x81, 0xC9, 0x03, 0x4B,
+	// Bytes 30c0 - 30ff
+	0xCC, 0x8C, 0xC9, 0x03, 0x4B, 0xCC, 0xA3, 0xB5,
+	0x03, 0x4B, 0xCC, 0xA7, 0xA5, 0x03, 0x4B, 0xCC,
+	0xB1, 0xB5, 0x03, 0x4C, 0xCC, 0x81, 0xC9, 0x03,
+	0x4C, 0xCC, 0x8C, 0xC9, 0x03, 0x4C, 0xCC, 0xA7,
+	0xA5, 0x03, 0x4C, 0xCC, 0xAD, 0xB5, 0x03, 0x4C,
+	0xCC, 0xB1, 0xB5, 0x03, 0x4D, 0xCC, 0x81, 0xC9,
+	0x03, 0x4D, 0xCC, 0x87, 0xC9, 0x03, 0x4D, 0xCC,
+	0xA3, 0xB5, 0x03, 0x4E, 0xCC, 0x80, 0xC9, 0x03,
+	// Bytes 3100 - 313f
+	0x4E, 0xCC, 0x81, 0xC9, 0x03, 0x4E, 0xCC, 0x83,
+	0xC9, 0x03, 0x4E, 0xCC, 0x87, 0xC9, 0x03, 0x4E,
+	0xCC, 0x8C, 0xC9, 0x03, 0x4E, 0xCC, 0xA3, 0xB5,
+	0x03, 0x4E, 0xCC, 0xA7, 0xA5, 0x03, 0x4E, 0xCC,
+	0xAD, 0xB5, 0x03, 0x4E, 0xCC, 0xB1, 0xB5, 0x03,
+	0x4F, 0xCC, 0x80, 0xC9, 0x03, 0x4F, 0xCC, 0x81,
+	0xC9, 0x03, 0x4F, 0xCC, 0x86, 0xC9, 0x03, 0x4F,
+	0xCC, 0x89, 0xC9, 0x03, 0x4F, 0xCC, 0x8B, 0xC9,
+	// Bytes 3140 - 317f
+	0x03, 0x4F, 0xCC, 0x8C, 0xC9, 0x03, 0x4F, 0xCC,
+	0x8F, 0xC9, 0x03, 0x4F, 0xCC, 0x91, 0xC9, 0x03,
+	0x50, 0xCC, 0x81, 0xC9, 0x03, 0x50, 0xCC, 0x87,
+	0xC9, 0x03, 0x52, 0xCC, 0x81, 0xC9, 0x03, 0x52,
+	0xCC, 0x87, 0xC9, 0x03, 0x52, 0xCC, 0x8C, 0xC9,
+	0x03, 0x52, 0xCC, 0x8F, 0xC9, 0x03, 0x52, 0xCC,
+	0x91, 0xC9, 0x03, 0x52, 0xCC, 0xA7, 0xA5, 0x03,
+	0x52, 0xCC, 0xB1, 0xB5, 0x03, 0x53, 0xCC, 0x82,
+	// Bytes 3180 - 31bf
+	0xC9, 0x03, 0x53, 0xCC, 0x87, 0xC9, 0x03, 0x53,
+	0xCC, 0xA6, 0xB5, 0x03, 0x53, 0xCC, 0xA7, 0xA5,
+	0x03, 0x54, 0xCC, 0x87, 0xC9, 0x03, 0x54, 0xCC,
+	0x8C, 0xC9, 0x03, 0x54, 0xCC, 0xA3, 0xB5, 0x03,
+	0x54, 0xCC, 0xA6, 0xB5, 0x03, 0x54, 0xCC, 0xA7,
+	0xA5, 0x03, 0x54, 0xCC, 0xAD, 0xB5, 0x03, 0x54,
+	0xCC, 0xB1, 0xB5, 0x03, 0x55, 0xCC, 0x80, 0xC9,
+	0x03, 0x55, 0xCC, 0x81, 0xC9, 0x03, 0x55, 0xCC,
+	// Bytes 31c0 - 31ff
+	0x82, 0xC9, 0x03, 0x55, 0xCC, 0x86, 0xC9, 0x03,
+	0x55, 0xCC, 0x89, 0xC9, 0x03, 0x55, 0xCC, 0x8A,
+	0xC9, 0x03, 0x55, 0xCC, 0x8B, 0xC9, 0x03, 0x55,
+	0xCC, 0x8C, 0xC9, 0x03, 0x55, 0xCC, 0x8F, 0xC9,
+	0x03, 0x55, 0xCC, 0x91, 0xC9, 0x03, 0x55, 0xCC,
+	0xA3, 0xB5, 0x03, 0x55, 0xCC, 0xA4, 0xB5, 0x03,
+	0x55, 0xCC, 0xA8, 0xA5, 0x03, 0x55, 0xCC, 0xAD,
+	0xB5, 0x03, 0x55, 0xCC, 0xB0, 0xB5, 0x03, 0x56,
+	// Bytes 3200 - 323f
+	0xCC, 0x83, 0xC9, 0x03, 0x56, 0xCC, 0xA3, 0xB5,
+	0x03, 0x57, 0xCC, 0x80, 0xC9, 0x03, 0x57, 0xCC,
+	0x81, 0xC9, 0x03, 0x57, 0xCC, 0x82, 0xC9, 0x03,
+	0x57, 0xCC, 0x87, 0xC9, 0x03, 0x57, 0xCC, 0x88,
+	0xC9, 0x03, 0x57, 0xCC, 0xA3, 0xB5, 0x03, 0x58,
+	0xCC, 0x87, 0xC9, 0x03, 0x58, 0xCC, 0x88, 0xC9,
+	0x03, 0x59, 0xCC, 0x80, 0xC9, 0x03, 0x59, 0xCC,
+	0x81, 0xC9, 0x03, 0x59, 0xCC, 0x82, 0xC9, 0x03,
+	// Bytes 3240 - 327f
+	0x59, 0xCC, 0x83, 0xC9, 0x03, 0x59, 0xCC, 0x84,
+	0xC9, 0x03, 0x59, 0xCC, 0x87, 0xC9, 0x03, 0x59,
+	0xCC, 0x88, 0xC9, 0x03, 0x59, 0xCC, 0x89, 0xC9,
+	0x03, 0x59, 0xCC, 0xA3, 0xB5, 0x03, 0x5A, 0xCC,
+	0x81, 0xC9, 0x03, 0x5A, 0xCC, 0x82, 0xC9, 0x03,
+	0x5A, 0xCC, 0x87, 0xC9, 0x03, 0x5A, 0xCC, 0x8C,
+	0xC9, 0x03, 0x5A, 0xCC, 0xA3, 0xB5, 0x03, 0x5A,
+	0xCC, 0xB1, 0xB5, 0x03, 0x61, 0xCC, 0x80, 0xC9,
+	// Bytes 3280 - 32bf
+	0x03, 0x61, 0xCC, 0x81, 0xC9, 0x03, 0x61, 0xCC,
+	0x83, 0xC9, 0x03, 0x61, 0xCC, 0x84, 0xC9, 0x03,
+	0x61, 0xCC, 0x89, 0xC9, 0x03, 0x61, 0xCC, 0x8C,
+	0xC9, 0x03, 0x61, 0xCC, 0x8F, 0xC9, 0x03, 0x61,
+	0xCC, 0x91, 0xC9, 0x03, 0x61, 0xCC, 0xA5, 0xB5,
+	0x03, 0x61, 0xCC, 0xA8, 0xA5, 0x03, 0x62, 0xCC,
+	0x87, 0xC9, 0x03, 0x62, 0xCC, 0xA3, 0xB5, 0x03,
+	0x62, 0xCC, 0xB1, 0xB5, 0x03, 0x63, 0xCC, 0x81,
+	// Bytes 32c0 - 32ff
+	0xC9, 0x03, 0x63, 0xCC, 0x82, 0xC9, 0x03, 0x63,
+	0xCC, 0x87, 0xC9, 0x03, 0x63, 0xCC, 0x8C, 0xC9,
+	0x03, 0x64, 0xCC, 0x87, 0xC9, 0x03, 0x64, 0xCC,
+	0x8C, 0xC9, 0x03, 0x64, 0xCC, 0xA3, 0xB5, 0x03,
+	0x64, 0xCC, 0xA7, 0xA5, 0x03, 0x64, 0xCC, 0xAD,
+	0xB5, 0x03, 0x64, 0xCC, 0xB1, 0xB5, 0x03, 0x65,
+	0xCC, 0x80, 0xC9, 0x03, 0x65, 0xCC, 0x81, 0xC9,
+	0x03, 0x65, 0xCC, 0x83, 0xC9, 0x03, 0x65, 0xCC,
+	// Bytes 3300 - 333f
+	0x86, 0xC9, 0x03, 0x65, 0xCC, 0x87, 0xC9, 0x03,
+	0x65, 0xCC, 0x88, 0xC9, 0x03, 0x65, 0xCC, 0x89,
+	0xC9, 0x03, 0x65, 0xCC, 0x8C, 0xC9, 0x03, 0x65,
+	0xCC, 0x8F, 0xC9, 0x03, 0x65, 0xCC, 0x91, 0xC9,
+	0x03, 0x65, 0xCC, 0xA8, 0xA5, 0x03, 0x65, 0xCC,
+	0xAD, 0xB5, 0x03, 0x65, 0xCC, 0xB0, 0xB5, 0x03,
+	0x66, 0xCC, 0x87, 0xC9, 0x03, 0x67, 0xCC, 0x81,
+	0xC9, 0x03, 0x67, 0xCC, 0x82, 0xC9, 0x03, 0x67,
+	// Bytes 3340 - 337f
+	0xCC, 0x84, 0xC9, 0x03, 0x67, 0xCC, 0x86, 0xC9,
+	0x03, 0x67, 0xCC, 0x87, 0xC9, 0x03, 0x67, 0xCC,
+	0x8C, 0xC9, 0x03, 0x67, 0xCC, 0xA7, 0xA5, 0x03,
+	0x68, 0xCC, 0x82, 0xC9, 0x03, 0x68, 0xCC, 0x87,
+	0xC9, 0x03, 0x68, 0xCC, 0x88, 0xC9, 0x03, 0x68,
+	0xCC, 0x8C, 0xC9, 0x03, 0x68, 0xCC, 0xA3, 0xB5,
+	0x03, 0x68, 0xCC, 0xA7, 0xA5, 0x03, 0x68, 0xCC,
+	0xAE, 0xB5, 0x03, 0x68, 0xCC, 0xB1, 0xB5, 0x03,
+	// Bytes 3380 - 33bf
+	0x69, 0xCC, 0x80, 0xC9, 0x03, 0x69, 0xCC, 0x81,
+	0xC9, 0x03, 0x69, 0xCC, 0x82, 0xC9, 0x03, 0x69,
+	0xCC, 0x83, 0xC9, 0x03, 0x69, 0xCC, 0x84, 0xC9,
+	0x03, 0x69, 0xCC, 0x86, 0xC9, 0x03, 0x69, 0xCC,
+	0x89, 0xC9, 0x03, 0x69, 0xCC, 0x8C, 0xC9, 0x03,
+	0x69, 0xCC, 0x8F, 0xC9, 0x03, 0x69, 0xCC, 0x91,
+	0xC9, 0x03, 0x69, 0xCC, 0xA3, 0xB5, 0x03, 0x69,
+	0xCC, 0xA8, 0xA5, 0x03, 0x69, 0xCC, 0xB0, 0xB5,
+	// Bytes 33c0 - 33ff
+	0x03, 0x6A, 0xCC, 0x82, 0xC9, 0x03, 0x6A, 0xCC,
+	0x8C, 0xC9, 0x03, 0x6B, 0xCC, 0x81, 0xC9, 0x03,
+	0x6B, 0xCC, 0x8C, 0xC9, 0x03, 0x6B, 0xCC, 0xA3,
+	0xB5, 0x03, 0x6B, 0xCC, 0xA7, 0xA5, 0x03, 0x6B,
+	0xCC, 0xB1, 0xB5, 0x03, 0x6C, 0xCC, 0x81, 0xC9,
+	0x03, 0x6C, 0xCC, 0x8C, 0xC9, 0x03, 0x6C, 0xCC,
+	0xA7, 0xA5, 0x03, 0x6C, 0xCC, 0xAD, 0xB5, 0x03,
+	0x6C, 0xCC, 0xB1, 0xB5, 0x03, 0x6D, 0xCC, 0x81,
+	// Bytes 3400 - 343f
+	0xC9, 0x03, 0x6D, 0xCC, 0x87, 0xC9, 0x03, 0x6D,
+	0xCC, 0xA3, 0xB5, 0x03, 0x6E, 0xCC, 0x80, 0xC9,
+	0x03, 0x6E, 0xCC, 0x81, 0xC9, 0x03, 0x6E, 0xCC,
+	0x83, 0xC9, 0x03, 0x6E, 0xCC, 0x87, 0xC9, 0x03,
+	0x6E, 0xCC, 0x8C, 0xC9, 0x03, 0x6E, 0xCC, 0xA3,
+	0xB5, 0x03, 0x6E, 0xCC, 0xA7, 0xA5, 0x03, 0x6E,
+	0xCC, 0xAD, 0xB5, 0x03, 0x6E, 0xCC, 0xB1, 0xB5,
+	0x03, 0x6F, 0xCC, 0x80, 0xC9, 0x03, 0x6F, 0xCC,
+	// Bytes 3440 - 347f
+	0x81, 0xC9, 0x03, 0x6F, 0xCC, 0x86, 0xC9, 0x03,
+	0x6F, 0xCC, 0x89, 0xC9, 0x03, 0x6F, 0xCC, 0x8B,
+	0xC9, 0x03, 0x6F, 0xCC, 0x8C, 0xC9, 0x03, 0x6F,
+	0xCC, 0x8F, 0xC9, 0x03, 0x6F, 0xCC, 0x91, 0xC9,
+	0x03, 0x70, 0xCC, 0x81, 0xC9, 0x03, 0x70, 0xCC,
+	0x87, 0xC9, 0x03, 0x72, 0xCC, 0x81, 0xC9, 0x03,
+	0x72, 0xCC, 0x87, 0xC9, 0x03, 0x72, 0xCC, 0x8C,
+	0xC9, 0x03, 0x72, 0xCC, 0x8F, 0xC9, 0x03, 0x72,
+	// Bytes 3480 - 34bf
+	0xCC, 0x91, 0xC9, 0x03, 0x72, 0xCC, 0xA7, 0xA5,
+	0x03, 0x72, 0xCC, 0xB1, 0xB5, 0x03, 0x73, 0xCC,
+	0x82, 0xC9, 0x03, 0x73, 0xCC, 0x87, 0xC9, 0x03,
+	0x73, 0xCC, 0xA6, 0xB5, 0x03, 0x73, 0xCC, 0xA7,
+	0xA5, 0x03, 0x74, 0xCC, 0x87, 0xC9, 0x03, 0x74,
+	0xCC, 0x88, 0xC9, 0x03, 0x74, 0xCC, 0x8C, 0xC9,
+	0x03, 0x74, 0xCC, 0xA3, 0xB5, 0x03, 0x74, 0xCC,
+	0xA6, 0xB5, 0x03, 0x74, 0xCC, 0xA7, 0xA5, 0x03,
+	// Bytes 34c0 - 34ff
+	0x74, 0xCC, 0xAD, 0xB5, 0x03, 0x74, 0xCC, 0xB1,
+	0xB5, 0x03, 0x75, 0xCC, 0x80, 0xC9, 0x03, 0x75,
+	0xCC, 0x81, 0xC9, 0x03, 0x75, 0xCC, 0x82, 0xC9,
+	0x03, 0x75, 0xCC, 0x86, 0xC9, 0x03, 0x75, 0xCC,
+	0x89, 0xC9, 0x03, 0x75, 0xCC, 0x8A, 0xC9, 0x03,
+	0x75, 0xCC, 0x8B, 0xC9, 0x03, 0x75, 0xCC, 0x8C,
+	0xC9, 0x03, 0x75, 0xCC, 0x8F, 0xC9, 0x03, 0x75,
+	0xCC, 0x91, 0xC9, 0x03, 0x75, 0xCC, 0xA3, 0xB5,
+	// Bytes 3500 - 353f
+	0x03, 0x75, 0xCC, 0xA4, 0xB5, 0x03, 0x75, 0xCC,
+	0xA8, 0xA5, 0x03, 0x75, 0xCC, 0xAD, 0xB5, 0x03,
+	0x75, 0xCC, 0xB0, 0xB5, 0x03, 0x76, 0xCC, 0x83,
+	0xC9, 0x03, 0x76, 0xCC, 0xA3, 0xB5, 0x03, 0x77,
+	0xCC, 0x80, 0xC9, 0x03, 0x77, 0xCC, 0x81, 0xC9,
+	0x03, 0x77, 0xCC, 0x82, 0xC9, 0x03, 0x77, 0xCC,
+	0x87, 0xC9, 0x03, 0x77, 0xCC, 0x88, 0xC9, 0x03,
+	0x77, 0xCC, 0x8A, 0xC9, 0x03, 0x77, 0xCC, 0xA3,
+	// Bytes 3540 - 357f
+	0xB5, 0x03, 0x78, 0xCC, 0x87, 0xC9, 0x03, 0x78,
+	0xCC, 0x88, 0xC9, 0x03, 0x79, 0xCC, 0x80, 0xC9,
+	0x03, 0x79, 0xCC, 0x81, 0xC9, 0x03, 0x79, 0xCC,
+	0x82, 0xC9, 0x03, 0x79, 0xCC, 0x83, 0xC9, 0x03,
+	0x79, 0xCC, 0x84, 0xC9, 0x03, 0x79, 0xCC, 0x87,
+	0xC9, 0x03, 0x79, 0xCC, 0x88, 0xC9, 0x03, 0x79,
+	0xCC, 0x89, 0xC9, 0x03, 0x79, 0xCC, 0x8A, 0xC9,
+	0x03, 0x79, 0xCC, 0xA3, 0xB5, 0x03, 0x7A, 0xCC,
+	// Bytes 3580 - 35bf
+	0x81, 0xC9, 0x03, 0x7A, 0xCC, 0x82, 0xC9, 0x03,
+	0x7A, 0xCC, 0x87, 0xC9, 0x03, 0x7A, 0xCC, 0x8C,
+	0xC9, 0x03, 0x7A, 0xCC, 0xA3, 0xB5, 0x03, 0x7A,
+	0xCC, 0xB1, 0xB5, 0x04, 0xC2, 0xA8, 0xCC, 0x80,
+	0xCA, 0x04, 0xC2, 0xA8, 0xCC, 0x81, 0xCA, 0x04,
+	0xC2, 0xA8, 0xCD, 0x82, 0xCA, 0x04, 0xC3, 0x86,
+	0xCC, 0x81, 0xC9, 0x04, 0xC3, 0x86, 0xCC, 0x84,
+	0xC9, 0x04, 0xC3, 0x98, 0xCC, 0x81, 0xC9, 0x04,
+	// Bytes 35c0 - 35ff
+	0xC3, 0xA6, 0xCC, 0x81, 0xC9, 0x04, 0xC3, 0xA6,
+	0xCC, 0x84, 0xC9, 0x04, 0xC3, 0xB8, 0xCC, 0x81,
+	0xC9, 0x04, 0xC5, 0xBF, 0xCC, 0x87, 0xC9, 0x04,
+	0xC6, 0xB7, 0xCC, 0x8C, 0xC9, 0x04, 0xCA, 0x92,
+	0xCC, 0x8C, 0xC9, 0x04, 0xCE, 0x91, 0xCC, 0x80,
+	0xC9, 0x04, 0xCE, 0x91, 0xCC, 0x81, 0xC9, 0x04,
+	0xCE, 0x91, 0xCC, 0x84, 0xC9, 0x04, 0xCE, 0x91,
+	0xCC, 0x86, 0xC9, 0x04, 0xCE, 0x91, 0xCD, 0x85,
+	// Bytes 3600 - 363f
+	0xD9, 0x04, 0xCE, 0x95, 0xCC, 0x80, 0xC9, 0x04,
+	0xCE, 0x95, 0xCC, 0x81, 0xC9, 0x04, 0xCE, 0x97,
+	0xCC, 0x80, 0xC9, 0x04, 0xCE, 0x97, 0xCC, 0x81,
+	0xC9, 0x04, 0xCE, 0x97, 0xCD, 0x85, 0xD9, 0x04,
+	0xCE, 0x99, 0xCC, 0x80, 0xC9, 0x04, 0xCE, 0x99,
+	0xCC, 0x81, 0xC9, 0x04, 0xCE, 0x99, 0xCC, 0x84,
+	0xC9, 0x04, 0xCE, 0x99, 0xCC, 0x86, 0xC9, 0x04,
+	0xCE, 0x99, 0xCC, 0x88, 0xC9, 0x04, 0xCE, 0x9F,
+	// Bytes 3640 - 367f
+	0xCC, 0x80, 0xC9, 0x04, 0xCE, 0x9F, 0xCC, 0x81,
+	0xC9, 0x04, 0xCE, 0xA1, 0xCC, 0x94, 0xC9, 0x04,
+	0xCE, 0xA5, 0xCC, 0x80, 0xC9, 0x04, 0xCE, 0xA5,
+	0xCC, 0x81, 0xC9, 0x04, 0xCE, 0xA5, 0xCC, 0x84,
+	0xC9, 0x04, 0xCE, 0xA5, 0xCC, 0x86, 0xC9, 0x04,
+	0xCE, 0xA5, 0xCC, 0x88, 0xC9, 0x04, 0xCE, 0xA9,
+	0xCC, 0x80, 0xC9, 0x04, 0xCE, 0xA9, 0xCC, 0x81,
+	0xC9, 0x04, 0xCE, 0xA9, 0xCD, 0x85, 0xD9, 0x04,
+	// Bytes 3680 - 36bf
+	0xCE, 0xB1, 0xCC, 0x84, 0xC9, 0x04, 0xCE, 0xB1,
+	0xCC, 0x86, 0xC9, 0x04, 0xCE, 0xB1, 0xCD, 0x85,
+	0xD9, 0x04, 0xCE, 0xB5, 0xCC, 0x80, 0xC9, 0x04,
+	0xCE, 0xB5, 0xCC, 0x81, 0xC9, 0x04, 0xCE, 0xB7,
+	0xCD, 0x85, 0xD9, 0x04, 0xCE, 0xB9, 0xCC, 0x80,
+	0xC9, 0x04, 0xCE, 0xB9, 0xCC, 0x81, 0xC9, 0x04,
+	0xCE, 0xB9, 0xCC, 0x84, 0xC9, 0x04, 0xCE, 0xB9,
+	0xCC, 0x86, 0xC9, 0x04, 0xCE, 0xB9, 0xCD, 0x82,
+	// Bytes 36c0 - 36ff
+	0xC9, 0x04, 0xCE, 0xBF, 0xCC, 0x80, 0xC9, 0x04,
+	0xCE, 0xBF, 0xCC, 0x81, 0xC9, 0x04, 0xCF, 0x81,
+	0xCC, 0x93, 0xC9, 0x04, 0xCF, 0x81, 0xCC, 0x94,
+	0xC9, 0x04, 0xCF, 0x85, 0xCC, 0x80, 0xC9, 0x04,
+	0xCF, 0x85, 0xCC, 0x81, 0xC9, 0x04, 0xCF, 0x85,
+	0xCC, 0x84, 0xC9, 0x04, 0xCF, 0x85, 0xCC, 0x86,
+	0xC9, 0x04, 0xCF, 0x85, 0xCD, 0x82, 0xC9, 0x04,
+	0xCF, 0x89, 0xCD, 0x85, 0xD9, 0x04, 0xCF, 0x92,
+	// Bytes 3700 - 373f
+	0xCC, 0x81, 0xC9, 0x04, 0xCF, 0x92, 0xCC, 0x88,
+	0xC9, 0x04, 0xD0, 0x86, 0xCC, 0x88, 0xC9, 0x04,
+	0xD0, 0x90, 0xCC, 0x86, 0xC9, 0x04, 0xD0, 0x90,
+	0xCC, 0x88, 0xC9, 0x04, 0xD0, 0x93, 0xCC, 0x81,
+	0xC9, 0x04, 0xD0, 0x95, 0xCC, 0x80, 0xC9, 0x04,
+	0xD0, 0x95, 0xCC, 0x86, 0xC9, 0x04, 0xD0, 0x95,
+	0xCC, 0x88, 0xC9, 0x04, 0xD0, 0x96, 0xCC, 0x86,
+	0xC9, 0x04, 0xD0, 0x96, 0xCC, 0x88, 0xC9, 0x04,
+	// Bytes 3740 - 377f
+	0xD0, 0x97, 0xCC, 0x88, 0xC9, 0x04, 0xD0, 0x98,
+	0xCC, 0x80, 0xC9, 0x04, 0xD0, 0x98, 0xCC, 0x84,
+	0xC9, 0x04, 0xD0, 0x98, 0xCC, 0x86, 0xC9, 0x04,
+	0xD0, 0x98, 0xCC, 0x88, 0xC9, 0x04, 0xD0, 0x9A,
+	0xCC, 0x81, 0xC9, 0x04, 0xD0, 0x9E, 0xCC, 0x88,
+	0xC9, 0x04, 0xD0, 0xA3, 0xCC, 0x84, 0xC9, 0x04,
+	0xD0, 0xA3, 0xCC, 0x86, 0xC9, 0x04, 0xD0, 0xA3,
+	0xCC, 0x88, 0xC9, 0x04, 0xD0, 0xA3, 0xCC, 0x8B,
+	// Bytes 3780 - 37bf
+	0xC9, 0x04, 0xD0, 0xA7, 0xCC, 0x88, 0xC9, 0x04,
+	0xD0, 0xAB, 0xCC, 0x88, 0xC9, 0x04, 0xD0, 0xAD,
+	0xCC, 0x88, 0xC9, 0x04, 0xD0, 0xB0, 0xCC, 0x86,
+	0xC9, 0x04, 0xD0, 0xB0, 0xCC, 0x88, 0xC9, 0x04,
+	0xD0, 0xB3, 0xCC, 0x81, 0xC9, 0x04, 0xD0, 0xB5,
+	0xCC, 0x80, 0xC9, 0x04, 0xD0, 0xB5, 0xCC, 0x86,
+	0xC9, 0x04, 0xD0, 0xB5, 0xCC, 0x88, 0xC9, 0x04,
+	0xD0, 0xB6, 0xCC, 0x86, 0xC9, 0x04, 0xD0, 0xB6,
+	// Bytes 37c0 - 37ff
+	0xCC, 0x88, 0xC9, 0x04, 0xD0, 0xB7, 0xCC, 0x88,
+	0xC9, 0x04, 0xD0, 0xB8, 0xCC, 0x80, 0xC9, 0x04,
+	0xD0, 0xB8, 0xCC, 0x84, 0xC9, 0x04, 0xD0, 0xB8,
+	0xCC, 0x86, 0xC9, 0x04, 0xD0, 0xB8, 0xCC, 0x88,
+	0xC9, 0x04, 0xD0, 0xBA, 0xCC, 0x81, 0xC9, 0x04,
+	0xD0, 0xBE, 0xCC, 0x88, 0xC9, 0x04, 0xD1, 0x83,
+	0xCC, 0x84, 0xC9, 0x04, 0xD1, 0x83, 0xCC, 0x86,
+	0xC9, 0x04, 0xD1, 0x83, 0xCC, 0x88, 0xC9, 0x04,
+	// Bytes 3800 - 383f
+	0xD1, 0x83, 0xCC, 0x8B, 0xC9, 0x04, 0xD1, 0x87,
+	0xCC, 0x88, 0xC9, 0x04, 0xD1, 0x8B, 0xCC, 0x88,
+	0xC9, 0x04, 0xD1, 0x8D, 0xCC, 0x88, 0xC9, 0x04,
+	0xD1, 0x96, 0xCC, 0x88, 0xC9, 0x04, 0xD1, 0xB4,
+	0xCC, 0x8F, 0xC9, 0x04, 0xD1, 0xB5, 0xCC, 0x8F,
+	0xC9, 0x04, 0xD3, 0x98, 0xCC, 0x88, 0xC9, 0x04,
+	0xD3, 0x99, 0xCC, 0x88, 0xC9, 0x04, 0xD3, 0xA8,
+	0xCC, 0x88, 0xC9, 0x04, 0xD3, 0xA9, 0xCC, 0x88,
+	// Bytes 3840 - 387f
+	0xC9, 0x04, 0xD8, 0xA7, 0xD9, 0x93, 0xC9, 0x04,
+	0xD8, 0xA7, 0xD9, 0x94, 0xC9, 0x04, 0xD8, 0xA7,
+	0xD9, 0x95, 0xB5, 0x04, 0xD9, 0x88, 0xD9, 0x94,
+	0xC9, 0x04, 0xD9, 0x8A, 0xD9, 0x94, 0xC9, 0x04,
+	0xDB, 0x81, 0xD9, 0x94, 0xC9, 0x04, 0xDB, 0x92,
+	0xD9, 0x94, 0xC9, 0x04, 0xDB, 0x95, 0xD9, 0x94,
+	0xC9, 0x05, 0x41, 0xCC, 0x82, 0xCC, 0x80, 0xCA,
+	0x05, 0x41, 0xCC, 0x82, 0xCC, 0x81, 0xCA, 0x05,
+	// Bytes 3880 - 38bf
+	0x41, 0xCC, 0x82, 0xCC, 0x83, 0xCA, 0x05, 0x41,
+	0xCC, 0x82, 0xCC, 0x89, 0xCA, 0x05, 0x41, 0xCC,
+	0x86, 0xCC, 0x80, 0xCA, 0x05, 0x41, 0xCC, 0x86,
+	0xCC, 0x81, 0xCA, 0x05, 0x41, 0xCC, 0x86, 0xCC,
+	0x83, 0xCA, 0x05, 0x41, 0xCC, 0x86, 0xCC, 0x89,
+	0xCA, 0x05, 0x41, 0xCC, 0x87, 0xCC, 0x84, 0xCA,
+	0x05, 0x41, 0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05,
+	0x41, 0xCC, 0x8A, 0xCC, 0x81, 0xCA, 0x05, 0x41,
+	// Bytes 38c0 - 38ff
+	0xCC, 0xA3, 0xCC, 0x82, 0xCA, 0x05, 0x41, 0xCC,
+	0xA3, 0xCC, 0x86, 0xCA, 0x05, 0x43, 0xCC, 0xA7,
+	0xCC, 0x81, 0xCA, 0x05, 0x45, 0xCC, 0x82, 0xCC,
+	0x80, 0xCA, 0x05, 0x45, 0xCC, 0x82, 0xCC, 0x81,
+	0xCA, 0x05, 0x45, 0xCC, 0x82, 0xCC, 0x83, 0xCA,
+	0x05, 0x45, 0xCC, 0x82, 0xCC, 0x89, 0xCA, 0x05,
+	0x45, 0xCC, 0x84, 0xCC, 0x80, 0xCA, 0x05, 0x45,
+	0xCC, 0x84, 0xCC, 0x81, 0xCA, 0x05, 0x45, 0xCC,
+	// Bytes 3900 - 393f
+	0xA3, 0xCC, 0x82, 0xCA, 0x05, 0x45, 0xCC, 0xA7,
+	0xCC, 0x86, 0xCA, 0x05, 0x49, 0xCC, 0x88, 0xCC,
+	0x81, 0xCA, 0x05, 0x4C, 0xCC, 0xA3, 0xCC, 0x84,
+	0xCA, 0x05, 0x4F, 0xCC, 0x82, 0xCC, 0x80, 0xCA,
+	0x05, 0x4F, 0xCC, 0x82, 0xCC, 0x81, 0xCA, 0x05,
+	0x4F, 0xCC, 0x82, 0xCC, 0x83, 0xCA, 0x05, 0x4F,
+	0xCC, 0x82, 0xCC, 0x89, 0xCA, 0x05, 0x4F, 0xCC,
+	0x83, 0xCC, 0x81, 0xCA, 0x05, 0x4F, 0xCC, 0x83,
+	// Bytes 3940 - 397f
+	0xCC, 0x84, 0xCA, 0x05, 0x4F, 0xCC, 0x83, 0xCC,
+	0x88, 0xCA, 0x05, 0x4F, 0xCC, 0x84, 0xCC, 0x80,
+	0xCA, 0x05, 0x4F, 0xCC, 0x84, 0xCC, 0x81, 0xCA,
+	0x05, 0x4F, 0xCC, 0x87, 0xCC, 0x84, 0xCA, 0x05,
+	0x4F, 0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05, 0x4F,
+	0xCC, 0x9B, 0xCC, 0x80, 0xCA, 0x05, 0x4F, 0xCC,
+	0x9B, 0xCC, 0x81, 0xCA, 0x05, 0x4F, 0xCC, 0x9B,
+	0xCC, 0x83, 0xCA, 0x05, 0x4F, 0xCC, 0x9B, 0xCC,
+	// Bytes 3980 - 39bf
+	0x89, 0xCA, 0x05, 0x4F, 0xCC, 0x9B, 0xCC, 0xA3,
+	0xB6, 0x05, 0x4F, 0xCC, 0xA3, 0xCC, 0x82, 0xCA,
+	0x05, 0x4F, 0xCC, 0xA8, 0xCC, 0x84, 0xCA, 0x05,
+	0x52, 0xCC, 0xA3, 0xCC, 0x84, 0xCA, 0x05, 0x53,
+	0xCC, 0x81, 0xCC, 0x87, 0xCA, 0x05, 0x53, 0xCC,
+	0x8C, 0xCC, 0x87, 0xCA, 0x05, 0x53, 0xCC, 0xA3,
+	0xCC, 0x87, 0xCA, 0x05, 0x55, 0xCC, 0x83, 0xCC,
+	0x81, 0xCA, 0x05, 0x55, 0xCC, 0x84, 0xCC, 0x88,
+	// Bytes 39c0 - 39ff
+	0xCA, 0x05, 0x55, 0xCC, 0x88, 0xCC, 0x80, 0xCA,
+	0x05, 0x55, 0xCC, 0x88, 0xCC, 0x81, 0xCA, 0x05,
+	0x55, 0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05, 0x55,
+	0xCC, 0x88, 0xCC, 0x8C, 0xCA, 0x05, 0x55, 0xCC,
+	0x9B, 0xCC, 0x80, 0xCA, 0x05, 0x55, 0xCC, 0x9B,
+	0xCC, 0x81, 0xCA, 0x05, 0x55, 0xCC, 0x9B, 0xCC,
+	0x83, 0xCA, 0x05, 0x55, 0xCC, 0x9B, 0xCC, 0x89,
+	0xCA, 0x05, 0x55, 0xCC, 0x9B, 0xCC, 0xA3, 0xB6,
+	// Bytes 3a00 - 3a3f
+	0x05, 0x61, 0xCC, 0x82, 0xCC, 0x80, 0xCA, 0x05,
+	0x61, 0xCC, 0x82, 0xCC, 0x81, 0xCA, 0x05, 0x61,
+	0xCC, 0x82, 0xCC, 0x83, 0xCA, 0x05, 0x61, 0xCC,
+	0x82, 0xCC, 0x89, 0xCA, 0x05, 0x61, 0xCC, 0x86,
+	0xCC, 0x80, 0xCA, 0x05, 0x61, 0xCC, 0x86, 0xCC,
+	0x81, 0xCA, 0x05, 0x61, 0xCC, 0x86, 0xCC, 0x83,
+	0xCA, 0x05, 0x61, 0xCC, 0x86, 0xCC, 0x89, 0xCA,
+	0x05, 0x61, 0xCC, 0x87, 0xCC, 0x84, 0xCA, 0x05,
+	// Bytes 3a40 - 3a7f
+	0x61, 0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05, 0x61,
+	0xCC, 0x8A, 0xCC, 0x81, 0xCA, 0x05, 0x61, 0xCC,
+	0xA3, 0xCC, 0x82, 0xCA, 0x05, 0x61, 0xCC, 0xA3,
+	0xCC, 0x86, 0xCA, 0x05, 0x63, 0xCC, 0xA7, 0xCC,
+	0x81, 0xCA, 0x05, 0x65, 0xCC, 0x82, 0xCC, 0x80,
+	0xCA, 0x05, 0x65, 0xCC, 0x82, 0xCC, 0x81, 0xCA,
+	0x05, 0x65, 0xCC, 0x82, 0xCC, 0x83, 0xCA, 0x05,
+	0x65, 0xCC, 0x82, 0xCC, 0x89, 0xCA, 0x05, 0x65,
+	// Bytes 3a80 - 3abf
+	0xCC, 0x84, 0xCC, 0x80, 0xCA, 0x05, 0x65, 0xCC,
+	0x84, 0xCC, 0x81, 0xCA, 0x05, 0x65, 0xCC, 0xA3,
+	0xCC, 0x82, 0xCA, 0x05, 0x65, 0xCC, 0xA7, 0xCC,
+	0x86, 0xCA, 0x05, 0x69, 0xCC, 0x88, 0xCC, 0x81,
+	0xCA, 0x05, 0x6C, 0xCC, 0xA3, 0xCC, 0x84, 0xCA,
+	0x05, 0x6F, 0xCC, 0x82, 0xCC, 0x80, 0xCA, 0x05,
+	0x6F, 0xCC, 0x82, 0xCC, 0x81, 0xCA, 0x05, 0x6F,
+	0xCC, 0x82, 0xCC, 0x83, 0xCA, 0x05, 0x6F, 0xCC,
+	// Bytes 3ac0 - 3aff
+	0x82, 0xCC, 0x89, 0xCA, 0x05, 0x6F, 0xCC, 0x83,
+	0xCC, 0x81, 0xCA, 0x05, 0x6F, 0xCC, 0x83, 0xCC,
+	0x84, 0xCA, 0x05, 0x6F, 0xCC, 0x83, 0xCC, 0x88,
+	0xCA, 0x05, 0x6F, 0xCC, 0x84, 0xCC, 0x80, 0xCA,
+	0x05, 0x6F, 0xCC, 0x84, 0xCC, 0x81, 0xCA, 0x05,
+	0x6F, 0xCC, 0x87, 0xCC, 0x84, 0xCA, 0x05, 0x6F,
+	0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05, 0x6F, 0xCC,
+	0x9B, 0xCC, 0x80, 0xCA, 0x05, 0x6F, 0xCC, 0x9B,
+	// Bytes 3b00 - 3b3f
+	0xCC, 0x81, 0xCA, 0x05, 0x6F, 0xCC, 0x9B, 0xCC,
+	0x83, 0xCA, 0x05, 0x6F, 0xCC, 0x9B, 0xCC, 0x89,
+	0xCA, 0x05, 0x6F, 0xCC, 0x9B, 0xCC, 0xA3, 0xB6,
+	0x05, 0x6F, 0xCC, 0xA3, 0xCC, 0x82, 0xCA, 0x05,
+	0x6F, 0xCC, 0xA8, 0xCC, 0x84, 0xCA, 0x05, 0x72,
+	0xCC, 0xA3, 0xCC, 0x84, 0xCA, 0x05, 0x73, 0xCC,
+	0x81, 0xCC, 0x87, 0xCA, 0x05, 0x73, 0xCC, 0x8C,
+	0xCC, 0x87, 0xCA, 0x05, 0x73, 0xCC, 0xA3, 0xCC,
+	// Bytes 3b40 - 3b7f
+	0x87, 0xCA, 0x05, 0x75, 0xCC, 0x83, 0xCC, 0x81,
+	0xCA, 0x05, 0x75, 0xCC, 0x84, 0xCC, 0x88, 0xCA,
+	0x05, 0x75, 0xCC, 0x88, 0xCC, 0x80, 0xCA, 0x05,
+	0x75, 0xCC, 0x88, 0xCC, 0x81, 0xCA, 0x05, 0x75,
+	0xCC, 0x88, 0xCC, 0x84, 0xCA, 0x05, 0x75, 0xCC,
+	0x88, 0xCC, 0x8C, 0xCA, 0x05, 0x75, 0xCC, 0x9B,
+	0xCC, 0x80, 0xCA, 0x05, 0x75, 0xCC, 0x9B, 0xCC,
+	0x81, 0xCA, 0x05, 0x75, 0xCC, 0x9B, 0xCC, 0x83,
+	// Bytes 3b80 - 3bbf
+	0xCA, 0x05, 0x75, 0xCC, 0x9B, 0xCC, 0x89, 0xCA,
+	0x05, 0x75, 0xCC, 0x9B, 0xCC, 0xA3, 0xB6, 0x05,
+	0xE1, 0xBE, 0xBF, 0xCC, 0x80, 0xCA, 0x05, 0xE1,
+	0xBE, 0xBF, 0xCC, 0x81, 0xCA, 0x05, 0xE1, 0xBE,
+	0xBF, 0xCD, 0x82, 0xCA, 0x05, 0xE1, 0xBF, 0xBE,
+	0xCC, 0x80, 0xCA, 0x05, 0xE1, 0xBF, 0xBE, 0xCC,
+	0x81, 0xCA, 0x05, 0xE1, 0xBF, 0xBE, 0xCD, 0x82,
+	0xCA, 0x05, 0xE2, 0x86, 0x90, 0xCC, 0xB8, 0x05,
+	// Bytes 3bc0 - 3bff
+	0x05, 0xE2, 0x86, 0x92, 0xCC, 0xB8, 0x05, 0x05,
+	0xE2, 0x86, 0x94, 0xCC, 0xB8, 0x05, 0x05, 0xE2,
+	0x87, 0x90, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x87,
+	0x92, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x87, 0x94,
+	0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x88, 0x83, 0xCC,
+	0xB8, 0x05, 0x05, 0xE2, 0x88, 0x88, 0xCC, 0xB8,
+	0x05, 0x05, 0xE2, 0x88, 0x8B, 0xCC, 0xB8, 0x05,
+	0x05, 0xE2, 0x88, 0xA3, 0xCC, 0xB8, 0x05, 0x05,
+	// Bytes 3c00 - 3c3f
+	0xE2, 0x88, 0xA5, 0xCC, 0xB8, 0x05, 0x05, 0xE2,
+	0x88, 0xBC, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89,
+	0x83, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89, 0x85,
+	0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89, 0x88, 0xCC,
+	0xB8, 0x05, 0x05, 0xE2, 0x89, 0x8D, 0xCC, 0xB8,
+	0x05, 0x05, 0xE2, 0x89, 0xA1, 0xCC, 0xB8, 0x05,
+	0x05, 0xE2, 0x89, 0xA4, 0xCC, 0xB8, 0x05, 0x05,
+	0xE2, 0x89, 0xA5, 0xCC, 0xB8, 0x05, 0x05, 0xE2,
+	// Bytes 3c40 - 3c7f
+	0x89, 0xB2, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89,
+	0xB3, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89, 0xB6,
+	0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x89, 0xB7, 0xCC,
+	0xB8, 0x05, 0x05, 0xE2, 0x89, 0xBA, 0xCC, 0xB8,
+	0x05, 0x05, 0xE2, 0x89, 0xBB, 0xCC, 0xB8, 0x05,
+	0x05, 0xE2, 0x89, 0xBC, 0xCC, 0xB8, 0x05, 0x05,
+	0xE2, 0x89, 0xBD, 0xCC, 0xB8, 0x05, 0x05, 0xE2,
+	0x8A, 0x82, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A,
+	// Bytes 3c80 - 3cbf
+	0x83, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A, 0x86,
+	0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A, 0x87, 0xCC,
+	0xB8, 0x05, 0x05, 0xE2, 0x8A, 0x91, 0xCC, 0xB8,
+	0x05, 0x05, 0xE2, 0x8A, 0x92, 0xCC, 0xB8, 0x05,
+	0x05, 0xE2, 0x8A, 0xA2, 0xCC, 0xB8, 0x05, 0x05,
+	0xE2, 0x8A, 0xA8, 0xCC, 0xB8, 0x05, 0x05, 0xE2,
+	0x8A, 0xA9, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A,
+	0xAB, 0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A, 0xB2,
+	// Bytes 3cc0 - 3cff
+	0xCC, 0xB8, 0x05, 0x05, 0xE2, 0x8A, 0xB3, 0xCC,
+	0xB8, 0x05, 0x05, 0xE2, 0x8A, 0xB4, 0xCC, 0xB8,
+	0x05, 0x05, 0xE2, 0x8A, 0xB5, 0xCC, 0xB8, 0x05,
+	0x06, 0xCE, 0x91, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0x91, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0x95, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0x95, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0x95, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	// Bytes 3d00 - 3d3f
+	0x06, 0xCE, 0x95, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0x97, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0x97, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0x99, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0x99, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0x99, 0xCC, 0x93, 0xCD, 0x82, 0xCA,
+	0x06, 0xCE, 0x99, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0x99, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	// Bytes 3d40 - 3d7f
+	0x06, 0xCE, 0x99, 0xCC, 0x94, 0xCD, 0x82, 0xCA,
+	0x06, 0xCE, 0x9F, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0x9F, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0x9F, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0x9F, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xA5, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xA5, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xA5, 0xCC, 0x94, 0xCD, 0x82, 0xCA,
+	// Bytes 3d80 - 3dbf
+	0x06, 0xCE, 0xA9, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xA9, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB1, 0xCC, 0x80, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB1, 0xCC, 0x81, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB1, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB1, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB1, 0xCD, 0x82, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB5, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	// Bytes 3dc0 - 3dff
+	0x06, 0xCE, 0xB5, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xB5, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xB5, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xB7, 0xCC, 0x80, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB7, 0xCC, 0x81, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB7, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB7, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCE, 0xB7, 0xCD, 0x82, 0xCD, 0x85, 0xDA,
+	// Bytes 3e00 - 3e3f
+	0x06, 0xCE, 0xB9, 0xCC, 0x88, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x88, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x88, 0xCD, 0x82, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x93, 0xCD, 0x82, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xB9, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	// Bytes 3e40 - 3e7f
+	0x06, 0xCE, 0xB9, 0xCC, 0x94, 0xCD, 0x82, 0xCA,
+	0x06, 0xCE, 0xBF, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xBF, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCE, 0xBF, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCE, 0xBF, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x88, 0xCC, 0x80, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x88, 0xCC, 0x81, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x88, 0xCD, 0x82, 0xCA,
+	// Bytes 3e80 - 3ebf
+	0x06, 0xCF, 0x85, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x93, 0xCC, 0x81, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x93, 0xCD, 0x82, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x94, 0xCC, 0x80, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x94, 0xCC, 0x81, 0xCA,
+	0x06, 0xCF, 0x85, 0xCC, 0x94, 0xCD, 0x82, 0xCA,
+	0x06, 0xCF, 0x89, 0xCC, 0x80, 0xCD, 0x85, 0xDA,
+	0x06, 0xCF, 0x89, 0xCC, 0x81, 0xCD, 0x85, 0xDA,
+	// Bytes 3ec0 - 3eff
+	0x06, 0xCF, 0x89, 0xCC, 0x93, 0xCD, 0x85, 0xDA,
+	0x06, 0xCF, 0x89, 0xCC, 0x94, 0xCD, 0x85, 0xDA,
+	0x06, 0xCF, 0x89, 0xCD, 0x82, 0xCD, 0x85, 0xDA,
+	0x06, 0xE0, 0xA4, 0xA8, 0xE0, 0xA4, 0xBC, 0x09,
+	0x06, 0xE0, 0xA4, 0xB0, 0xE0, 0xA4, 0xBC, 0x09,
+	0x06, 0xE0, 0xA4, 0xB3, 0xE0, 0xA4, 0xBC, 0x09,
+	0x06, 0xE0, 0xB1, 0x86, 0xE0, 0xB1, 0x96, 0x85,
+	0x06, 0xE0, 0xB7, 0x99, 0xE0, 0xB7, 0x8A, 0x11,
+	// Bytes 3f00 - 3f3f
+	0x06, 0xE3, 0x81, 0x86, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x8B, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x8D, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x8F, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x91, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x93, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x95, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x97, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 3f40 - 3f7f
+	0x06, 0xE3, 0x81, 0x99, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x9B, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x9D, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0x9F, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xA1, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xA4, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xA6, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xA8, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 3f80 - 3fbf
+	0x06, 0xE3, 0x81, 0xAF, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xAF, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x81, 0xB2, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xB2, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x81, 0xB5, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xB5, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x81, 0xB8, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xB8, 0xE3, 0x82, 0x9A, 0x0D,
+	// Bytes 3fc0 - 3fff
+	0x06, 0xE3, 0x81, 0xBB, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x81, 0xBB, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x82, 0x9D, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xA6, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xAB, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xAD, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xAF, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xB1, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 4000 - 403f
+	0x06, 0xE3, 0x82, 0xB3, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xB5, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xB7, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xB9, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xBB, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xBD, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x82, 0xBF, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x81, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 4040 - 407f
+	0x06, 0xE3, 0x83, 0x84, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x86, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x88, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x8F, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x8F, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x92, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x83, 0x95, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 4080 - 40bf
+	0x06, 0xE3, 0x83, 0x95, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x83, 0x98, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x98, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x83, 0x9B, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0x9B, 0xE3, 0x82, 0x9A, 0x0D,
+	0x06, 0xE3, 0x83, 0xAF, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0xB0, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0xB1, 0xE3, 0x82, 0x99, 0x0D,
+	// Bytes 40c0 - 40ff
+	0x06, 0xE3, 0x83, 0xB2, 0xE3, 0x82, 0x99, 0x0D,
+	0x06, 0xE3, 0x83, 0xBD, 0xE3, 0x82, 0x99, 0x0D,
+	0x08, 0xCE, 0x91, 0xCC, 0x93, 0xCC, 0x80, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0x91, 0xCC, 0x93, 0xCC,
+	0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0x91, 0xCC,
+	0x93, 0xCD, 0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0x91, 0xCC, 0x94, 0xCC, 0x80, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0x91, 0xCC, 0x94, 0xCC, 0x81, 0xCD,
+	// Bytes 4100 - 413f
+	0x85, 0xDB, 0x08, 0xCE, 0x91, 0xCC, 0x94, 0xCD,
+	0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0x97, 0xCC,
+	0x93, 0xCC, 0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0x97, 0xCC, 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0x97, 0xCC, 0x93, 0xCD, 0x82, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0x97, 0xCC, 0x94, 0xCC,
+	0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0x97, 0xCC,
+	0x94, 0xCC, 0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	// Bytes 4140 - 417f
+	0x97, 0xCC, 0x94, 0xCD, 0x82, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0xA9, 0xCC, 0x93, 0xCC, 0x80, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0xA9, 0xCC, 0x93, 0xCC,
+	0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0xA9, 0xCC,
+	0x93, 0xCD, 0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0xA9, 0xCC, 0x94, 0xCC, 0x80, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0xA9, 0xCC, 0x94, 0xCC, 0x81, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0xA9, 0xCC, 0x94, 0xCD,
+	// Bytes 4180 - 41bf
+	0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0xB1, 0xCC,
+	0x93, 0xCC, 0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0xB1, 0xCC, 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0xB1, 0xCC, 0x93, 0xCD, 0x82, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0xB1, 0xCC, 0x94, 0xCC,
+	0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0xB1, 0xCC,
+	0x94, 0xCC, 0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0xB1, 0xCC, 0x94, 0xCD, 0x82, 0xCD, 0x85, 0xDB,
+	// Bytes 41c0 - 41ff
+	0x08, 0xCE, 0xB7, 0xCC, 0x93, 0xCC, 0x80, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0xB7, 0xCC, 0x93, 0xCC,
+	0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCE, 0xB7, 0xCC,
+	0x93, 0xCD, 0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCE,
+	0xB7, 0xCC, 0x94, 0xCC, 0x80, 0xCD, 0x85, 0xDB,
+	0x08, 0xCE, 0xB7, 0xCC, 0x94, 0xCC, 0x81, 0xCD,
+	0x85, 0xDB, 0x08, 0xCE, 0xB7, 0xCC, 0x94, 0xCD,
+	0x82, 0xCD, 0x85, 0xDB, 0x08, 0xCF, 0x89, 0xCC,
+	// Bytes 4200 - 423f
+	0x93, 0xCC, 0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCF,
+	0x89, 0xCC, 0x93, 0xCC, 0x81, 0xCD, 0x85, 0xDB,
+	0x08, 0xCF, 0x89, 0xCC, 0x93, 0xCD, 0x82, 0xCD,
+	0x85, 0xDB, 0x08, 0xCF, 0x89, 0xCC, 0x94, 0xCC,
+	0x80, 0xCD, 0x85, 0xDB, 0x08, 0xCF, 0x89, 0xCC,
+	0x94, 0xCC, 0x81, 0xCD, 0x85, 0xDB, 0x08, 0xCF,
+	0x89, 0xCC, 0x94, 0xCD, 0x82, 0xCD, 0x85, 0xDB,
+	0x08, 0xF0, 0x91, 0x82, 0x99, 0xF0, 0x91, 0x82,
+	// Bytes 4240 - 427f
+	0xBA, 0x09, 0x08, 0xF0, 0x91, 0x82, 0x9B, 0xF0,
+	0x91, 0x82, 0xBA, 0x09, 0x08, 0xF0, 0x91, 0x82,
+	0xA5, 0xF0, 0x91, 0x82, 0xBA, 0x09, 0x42, 0xC2,
+	0xB4, 0x01, 0x43, 0x20, 0xCC, 0x81, 0xC9, 0x43,
+	0x20, 0xCC, 0x83, 0xC9, 0x43, 0x20, 0xCC, 0x84,
+	0xC9, 0x43, 0x20, 0xCC, 0x85, 0xC9, 0x43, 0x20,
+	0xCC, 0x86, 0xC9, 0x43, 0x20, 0xCC, 0x87, 0xC9,
+	0x43, 0x20, 0xCC, 0x88, 0xC9, 0x43, 0x20, 0xCC,
+	// Bytes 4280 - 42bf
+	0x8A, 0xC9, 0x43, 0x20, 0xCC, 0x8B, 0xC9, 0x43,
+	0x20, 0xCC, 0x93, 0xC9, 0x43, 0x20, 0xCC, 0x94,
+	0xC9, 0x43, 0x20, 0xCC, 0xA7, 0xA5, 0x43, 0x20,
+	0xCC, 0xA8, 0xA5, 0x43, 0x20, 0xCC, 0xB3, 0xB5,
+	0x43, 0x20, 0xCD, 0x82, 0xC9, 0x43, 0x20, 0xCD,
+	0x85, 0xD9, 0x43, 0x20, 0xD9, 0x8B, 0x59, 0x43,
+	0x20, 0xD9, 0x8C, 0x5D, 0x43, 0x20, 0xD9, 0x8D,
+	0x61, 0x43, 0x20, 0xD9, 0x8E, 0x65, 0x43, 0x20,
+	// Bytes 42c0 - 42ff
+	0xD9, 0x8F, 0x69, 0x43, 0x20, 0xD9, 0x90, 0x6D,
+	0x43, 0x20, 0xD9, 0x91, 0x71, 0x43, 0x20, 0xD9,
+	0x92, 0x75, 0x43, 0x41, 0xCC, 0x8A, 0xC9, 0x43,
+	0x73, 0xCC, 0x87, 0xC9, 0x44, 0x20, 0xE3, 0x82,
+	0x99, 0x0D, 0x44, 0x20, 0xE3, 0x82, 0x9A, 0x0D,
+	0x44, 0xC2, 0xA8, 0xCC, 0x81, 0xCA, 0x44, 0xCE,
+	0x91, 0xCC, 0x81, 0xC9, 0x44, 0xCE, 0x95, 0xCC,
+	0x81, 0xC9, 0x44, 0xCE, 0x97, 0xCC, 0x81, 0xC9,
+	// Bytes 4300 - 433f
+	0x44, 0xCE, 0x99, 0xCC, 0x81, 0xC9, 0x44, 0xCE,
+	0x9F, 0xCC, 0x81, 0xC9, 0x44, 0xCE, 0xA5, 0xCC,
+	0x81, 0xC9, 0x44, 0xCE, 0xA5, 0xCC, 0x88, 0xC9,
+	0x44, 0xCE, 0xA9, 0xCC, 0x81, 0xC9, 0x44, 0xCE,
+	0xB1, 0xCC, 0x81, 0xC9, 0x44, 0xCE, 0xB5, 0xCC,
+	0x81, 0xC9, 0x44, 0xCE, 0xB7, 0xCC, 0x81, 0xC9,
+	0x44, 0xCE, 0xB9, 0xCC, 0x81, 0xC9, 0x44, 0xCE,
+	0xBF, 0xCC, 0x81, 0xC9, 0x44, 0xCF, 0x85, 0xCC,
+	// Bytes 4340 - 437f
+	0x81, 0xC9, 0x44, 0xCF, 0x89, 0xCC, 0x81, 0xC9,
+	0x44, 0xD7, 0x90, 0xD6, 0xB7, 0x31, 0x44, 0xD7,
+	0x90, 0xD6, 0xB8, 0x35, 0x44, 0xD7, 0x90, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0x91, 0xD6, 0xBC, 0x41,
+	0x44, 0xD7, 0x91, 0xD6, 0xBF, 0x49, 0x44, 0xD7,
+	0x92, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0x93, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0x94, 0xD6, 0xBC, 0x41,
+	0x44, 0xD7, 0x95, 0xD6, 0xB9, 0x39, 0x44, 0xD7,
+	// Bytes 4380 - 43bf
+	0x95, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0x96, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0x98, 0xD6, 0xBC, 0x41,
+	0x44, 0xD7, 0x99, 0xD6, 0xB4, 0x25, 0x44, 0xD7,
+	0x99, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0x9A, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0x9B, 0xD6, 0xBC, 0x41,
+	0x44, 0xD7, 0x9B, 0xD6, 0xBF, 0x49, 0x44, 0xD7,
+	0x9C, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0x9E, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0xA0, 0xD6, 0xBC, 0x41,
+	// Bytes 43c0 - 43ff
+	0x44, 0xD7, 0xA1, 0xD6, 0xBC, 0x41, 0x44, 0xD7,
+	0xA3, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0xA4, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0xA4, 0xD6, 0xBF, 0x49,
+	0x44, 0xD7, 0xA6, 0xD6, 0xBC, 0x41, 0x44, 0xD7,
+	0xA7, 0xD6, 0xBC, 0x41, 0x44, 0xD7, 0xA8, 0xD6,
+	0xBC, 0x41, 0x44, 0xD7, 0xA9, 0xD6, 0xBC, 0x41,
+	0x44, 0xD7, 0xA9, 0xD7, 0x81, 0x4D, 0x44, 0xD7,
+	0xA9, 0xD7, 0x82, 0x51, 0x44, 0xD7, 0xAA, 0xD6,
+	// Bytes 4400 - 443f
+	0xBC, 0x41, 0x44, 0xD7, 0xB2, 0xD6, 0xB7, 0x31,
+	0x44, 0xD8, 0xA7, 0xD9, 0x8B, 0x59, 0x44, 0xD8,
+	0xA7, 0xD9, 0x93, 0xC9, 0x44, 0xD8, 0xA7, 0xD9,
+	0x94, 0xC9, 0x44, 0xD8, 0xA7, 0xD9, 0x95, 0xB5,
+	0x44, 0xD8, 0xB0, 0xD9, 0xB0, 0x79, 0x44, 0xD8,
+	0xB1, 0xD9, 0xB0, 0x79, 0x44, 0xD9, 0x80, 0xD9,
+	0x8B, 0x59, 0x44, 0xD9, 0x80, 0xD9, 0x8E, 0x65,
+	0x44, 0xD9, 0x80, 0xD9, 0x8F, 0x69, 0x44, 0xD9,
+	// Bytes 4440 - 447f
+	0x80, 0xD9, 0x90, 0x6D, 0x44, 0xD9, 0x80, 0xD9,
+	0x91, 0x71, 0x44, 0xD9, 0x80, 0xD9, 0x92, 0x75,
+	0x44, 0xD9, 0x87, 0xD9, 0xB0, 0x79, 0x44, 0xD9,
+	0x88, 0xD9, 0x94, 0xC9, 0x44, 0xD9, 0x89, 0xD9,
+	0xB0, 0x79, 0x44, 0xD9, 0x8A, 0xD9, 0x94, 0xC9,
+	0x44, 0xDB, 0x92, 0xD9, 0x94, 0xC9, 0x44, 0xDB,
+	0x95, 0xD9, 0x94, 0xC9, 0x45, 0x20, 0xCC, 0x88,
+	0xCC, 0x80, 0xCA, 0x45, 0x20, 0xCC, 0x88, 0xCC,
+	// Bytes 4480 - 44bf
+	0x81, 0xCA, 0x45, 0x20, 0xCC, 0x88, 0xCD, 0x82,
+	0xCA, 0x45, 0x20, 0xCC, 0x93, 0xCC, 0x80, 0xCA,
+	0x45, 0x20, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x45,
+	0x20, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x45, 0x20,
+	0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x45, 0x20, 0xCC,
+	0x94, 0xCC, 0x81, 0xCA, 0x45, 0x20, 0xCC, 0x94,
+	0xCD, 0x82, 0xCA, 0x45, 0x20, 0xD9, 0x8C, 0xD9,
+	0x91, 0x72, 0x45, 0x20, 0xD9, 0x8D, 0xD9, 0x91,
+	// Bytes 44c0 - 44ff
+	0x72, 0x45, 0x20, 0xD9, 0x8E, 0xD9, 0x91, 0x72,
+	0x45, 0x20, 0xD9, 0x8F, 0xD9, 0x91, 0x72, 0x45,
+	0x20, 0xD9, 0x90, 0xD9, 0x91, 0x72, 0x45, 0x20,
+	0xD9, 0x91, 0xD9, 0xB0, 0x7A, 0x45, 0xE2, 0xAB,
+	0x9D, 0xCC, 0xB8, 0x05, 0x46, 0xCE, 0xB9, 0xCC,
+	0x88, 0xCC, 0x81, 0xCA, 0x46, 0xCF, 0x85, 0xCC,
+	0x88, 0xCC, 0x81, 0xCA, 0x46, 0xD7, 0xA9, 0xD6,
+	0xBC, 0xD7, 0x81, 0x4E, 0x46, 0xD7, 0xA9, 0xD6,
+	// Bytes 4500 - 453f
+	0xBC, 0xD7, 0x82, 0x52, 0x46, 0xD9, 0x80, 0xD9,
+	0x8E, 0xD9, 0x91, 0x72, 0x46, 0xD9, 0x80, 0xD9,
+	0x8F, 0xD9, 0x91, 0x72, 0x46, 0xD9, 0x80, 0xD9,
+	0x90, 0xD9, 0x91, 0x72, 0x46, 0xE0, 0xA4, 0x95,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0x96,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0x97,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0x9C,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0xA1,
+	// Bytes 4540 - 457f
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0xA2,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0xAB,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA4, 0xAF,
+	0xE0, 0xA4, 0xBC, 0x09, 0x46, 0xE0, 0xA6, 0xA1,
+	0xE0, 0xA6, 0xBC, 0x09, 0x46, 0xE0, 0xA6, 0xA2,
+	0xE0, 0xA6, 0xBC, 0x09, 0x46, 0xE0, 0xA6, 0xAF,
+	0xE0, 0xA6, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0x96,
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0x97,
+	// Bytes 4580 - 45bf
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0x9C,
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0xAB,
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0xB2,
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xA8, 0xB8,
+	0xE0, 0xA8, 0xBC, 0x09, 0x46, 0xE0, 0xAC, 0xA1,
+	0xE0, 0xAC, 0xBC, 0x09, 0x46, 0xE0, 0xAC, 0xA2,
+	0xE0, 0xAC, 0xBC, 0x09, 0x46, 0xE0, 0xBE, 0xB2,
+	0xE0, 0xBE, 0x80, 0x9D, 0x46, 0xE0, 0xBE, 0xB3,
+	// Bytes 45c0 - 45ff
+	0xE0, 0xBE, 0x80, 0x9D, 0x46, 0xE3, 0x83, 0x86,
+	0xE3, 0x82, 0x99, 0x0D, 0x48, 0xF0, 0x9D, 0x85,
+	0x97, 0xF0, 0x9D, 0x85, 0xA5, 0xAD, 0x48, 0xF0,
+	0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xAD,
+	0x48, 0xF0, 0x9D, 0x86, 0xB9, 0xF0, 0x9D, 0x85,
+	0xA5, 0xAD, 0x48, 0xF0, 0x9D, 0x86, 0xBA, 0xF0,
+	0x9D, 0x85, 0xA5, 0xAD, 0x49, 0xE0, 0xBE, 0xB2,
+	0xE0, 0xBD, 0xB1, 0xE0, 0xBE, 0x80, 0x9E, 0x49,
+	// Bytes 4600 - 463f
+	0xE0, 0xBE, 0xB3, 0xE0, 0xBD, 0xB1, 0xE0, 0xBE,
+	0x80, 0x9E, 0x4C, 0xF0, 0x9D, 0x85, 0x98, 0xF0,
+	0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xAE, 0xAE,
+	0x4C, 0xF0, 0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85,
+	0xA5, 0xF0, 0x9D, 0x85, 0xAF, 0xAE, 0x4C, 0xF0,
+	0x9D, 0x85, 0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xF0,
+	0x9D, 0x85, 0xB0, 0xAE, 0x4C, 0xF0, 0x9D, 0x85,
+	0x98, 0xF0, 0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85,
+	// Bytes 4640 - 467f
+	0xB1, 0xAE, 0x4C, 0xF0, 0x9D, 0x85, 0x98, 0xF0,
+	0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xB2, 0xAE,
+	0x4C, 0xF0, 0x9D, 0x86, 0xB9, 0xF0, 0x9D, 0x85,
+	0xA5, 0xF0, 0x9D, 0x85, 0xAE, 0xAE, 0x4C, 0xF0,
+	0x9D, 0x86, 0xB9, 0xF0, 0x9D, 0x85, 0xA5, 0xF0,
+	0x9D, 0x85, 0xAF, 0xAE, 0x4C, 0xF0, 0x9D, 0x86,
+	0xBA, 0xF0, 0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85,
+	0xAE, 0xAE, 0x4C, 0xF0, 0x9D, 0x86, 0xBA, 0xF0,
+	// Bytes 4680 - 46bf
+	0x9D, 0x85, 0xA5, 0xF0, 0x9D, 0x85, 0xAF, 0xAE,
+	0x83, 0x41, 0xCC, 0x82, 0xC9, 0x83, 0x41, 0xCC,
+	0x86, 0xC9, 0x83, 0x41, 0xCC, 0x87, 0xC9, 0x83,
+	0x41, 0xCC, 0x88, 0xC9, 0x83, 0x41, 0xCC, 0x8A,
+	0xC9, 0x83, 0x41, 0xCC, 0xA3, 0xB5, 0x83, 0x43,
+	0xCC, 0xA7, 0xA5, 0x83, 0x45, 0xCC, 0x82, 0xC9,
+	0x83, 0x45, 0xCC, 0x84, 0xC9, 0x83, 0x45, 0xCC,
+	0xA3, 0xB5, 0x83, 0x45, 0xCC, 0xA7, 0xA5, 0x83,
+	// Bytes 46c0 - 46ff
+	0x49, 0xCC, 0x88, 0xC9, 0x83, 0x4C, 0xCC, 0xA3,
+	0xB5, 0x83, 0x4F, 0xCC, 0x82, 0xC9, 0x83, 0x4F,
+	0xCC, 0x83, 0xC9, 0x83, 0x4F, 0xCC, 0x84, 0xC9,
+	0x83, 0x4F, 0xCC, 0x87, 0xC9, 0x83, 0x4F, 0xCC,
+	0x88, 0xC9, 0x83, 0x4F, 0xCC, 0x9B, 0xAD, 0x83,
+	0x4F, 0xCC, 0xA3, 0xB5, 0x83, 0x4F, 0xCC, 0xA8,
+	0xA5, 0x83, 0x52, 0xCC, 0xA3, 0xB5, 0x83, 0x53,
+	0xCC, 0x81, 0xC9, 0x83, 0x53, 0xCC, 0x8C, 0xC9,
+	// Bytes 4700 - 473f
+	0x83, 0x53, 0xCC, 0xA3, 0xB5, 0x83, 0x55, 0xCC,
+	0x83, 0xC9, 0x83, 0x55, 0xCC, 0x84, 0xC9, 0x83,
+	0x55, 0xCC, 0x88, 0xC9, 0x83, 0x55, 0xCC, 0x9B,
+	0xAD, 0x83, 0x61, 0xCC, 0x82, 0xC9, 0x83, 0x61,
+	0xCC, 0x86, 0xC9, 0x83, 0x61, 0xCC, 0x87, 0xC9,
+	0x83, 0x61, 0xCC, 0x88, 0xC9, 0x83, 0x61, 0xCC,
+	0x8A, 0xC9, 0x83, 0x61, 0xCC, 0xA3, 0xB5, 0x83,
+	0x63, 0xCC, 0xA7, 0xA5, 0x83, 0x65, 0xCC, 0x82,
+	// Bytes 4740 - 477f
+	0xC9, 0x83, 0x65, 0xCC, 0x84, 0xC9, 0x83, 0x65,
+	0xCC, 0xA3, 0xB5, 0x83, 0x65, 0xCC, 0xA7, 0xA5,
+	0x83, 0x69, 0xCC, 0x88, 0xC9, 0x83, 0x6C, 0xCC,
+	0xA3, 0xB5, 0x83, 0x6F, 0xCC, 0x82, 0xC9, 0x83,
+	0x6F, 0xCC, 0x83, 0xC9, 0x83, 0x6F, 0xCC, 0x84,
+	0xC9, 0x83, 0x6F, 0xCC, 0x87, 0xC9, 0x83, 0x6F,
+	0xCC, 0x88, 0xC9, 0x83, 0x6F, 0xCC, 0x9B, 0xAD,
+	0x83, 0x6F, 0xCC, 0xA3, 0xB5, 0x83, 0x6F, 0xCC,
+	// Bytes 4780 - 47bf
+	0xA8, 0xA5, 0x83, 0x72, 0xCC, 0xA3, 0xB5, 0x83,
+	0x73, 0xCC, 0x81, 0xC9, 0x83, 0x73, 0xCC, 0x8C,
+	0xC9, 0x83, 0x73, 0xCC, 0xA3, 0xB5, 0x83, 0x75,
+	0xCC, 0x83, 0xC9, 0x83, 0x75, 0xCC, 0x84, 0xC9,
+	0x83, 0x75, 0xCC, 0x88, 0xC9, 0x83, 0x75, 0xCC,
+	0x9B, 0xAD, 0x84, 0xCE, 0x91, 0xCC, 0x93, 0xC9,
+	0x84, 0xCE, 0x91, 0xCC, 0x94, 0xC9, 0x84, 0xCE,
+	0x95, 0xCC, 0x93, 0xC9, 0x84, 0xCE, 0x95, 0xCC,
+	// Bytes 47c0 - 47ff
+	0x94, 0xC9, 0x84, 0xCE, 0x97, 0xCC, 0x93, 0xC9,
+	0x84, 0xCE, 0x97, 0xCC, 0x94, 0xC9, 0x84, 0xCE,
+	0x99, 0xCC, 0x93, 0xC9, 0x84, 0xCE, 0x99, 0xCC,
+	0x94, 0xC9, 0x84, 0xCE, 0x9F, 0xCC, 0x93, 0xC9,
+	0x84, 0xCE, 0x9F, 0xCC, 0x94, 0xC9, 0x84, 0xCE,
+	0xA5, 0xCC, 0x94, 0xC9, 0x84, 0xCE, 0xA9, 0xCC,
+	0x93, 0xC9, 0x84, 0xCE, 0xA9, 0xCC, 0x94, 0xC9,
+	0x84, 0xCE, 0xB1, 0xCC, 0x80, 0xC9, 0x84, 0xCE,
+	// Bytes 4800 - 483f
+	0xB1, 0xCC, 0x81, 0xC9, 0x84, 0xCE, 0xB1, 0xCC,
+	0x93, 0xC9, 0x84, 0xCE, 0xB1, 0xCC, 0x94, 0xC9,
+	0x84, 0xCE, 0xB1, 0xCD, 0x82, 0xC9, 0x84, 0xCE,
+	0xB5, 0xCC, 0x93, 0xC9, 0x84, 0xCE, 0xB5, 0xCC,
+	0x94, 0xC9, 0x84, 0xCE, 0xB7, 0xCC, 0x80, 0xC9,
+	0x84, 0xCE, 0xB7, 0xCC, 0x81, 0xC9, 0x84, 0xCE,
+	0xB7, 0xCC, 0x93, 0xC9, 0x84, 0xCE, 0xB7, 0xCC,
+	0x94, 0xC9, 0x84, 0xCE, 0xB7, 0xCD, 0x82, 0xC9,
+	// Bytes 4840 - 487f
+	0x84, 0xCE, 0xB9, 0xCC, 0x88, 0xC9, 0x84, 0xCE,
+	0xB9, 0xCC, 0x93, 0xC9, 0x84, 0xCE, 0xB9, 0xCC,
+	0x94, 0xC9, 0x84, 0xCE, 0xBF, 0xCC, 0x93, 0xC9,
+	0x84, 0xCE, 0xBF, 0xCC, 0x94, 0xC9, 0x84, 0xCF,
+	0x85, 0xCC, 0x88, 0xC9, 0x84, 0xCF, 0x85, 0xCC,
+	0x93, 0xC9, 0x84, 0xCF, 0x85, 0xCC, 0x94, 0xC9,
+	0x84, 0xCF, 0x89, 0xCC, 0x80, 0xC9, 0x84, 0xCF,
+	0x89, 0xCC, 0x81, 0xC9, 0x84, 0xCF, 0x89, 0xCC,
+	// Bytes 4880 - 48bf
+	0x93, 0xC9, 0x84, 0xCF, 0x89, 0xCC, 0x94, 0xC9,
+	0x84, 0xCF, 0x89, 0xCD, 0x82, 0xC9, 0x86, 0xCE,
+	0x91, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0x91, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0x91, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0x91, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0x91, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0x91, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	// Bytes 48c0 - 48ff
+	0x97, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0x97, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0x97, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0x97, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0x97, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0x97, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xA9, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0xA9, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	// Bytes 4900 - 493f
+	0xA9, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xA9, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0xA9, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0xA9, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xB1, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0xB1, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0xB1, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xB1, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	// Bytes 4940 - 497f
+	0xB1, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0xB1, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCE,
+	0xB7, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x86, 0xCF,
+	// Bytes 4980 - 49bf
+	0x89, 0xCC, 0x93, 0xCC, 0x80, 0xCA, 0x86, 0xCF,
+	0x89, 0xCC, 0x93, 0xCC, 0x81, 0xCA, 0x86, 0xCF,
+	0x89, 0xCC, 0x93, 0xCD, 0x82, 0xCA, 0x86, 0xCF,
+	0x89, 0xCC, 0x94, 0xCC, 0x80, 0xCA, 0x86, 0xCF,
+	0x89, 0xCC, 0x94, 0xCC, 0x81, 0xCA, 0x86, 0xCF,
+	0x89, 0xCC, 0x94, 0xCD, 0x82, 0xCA, 0x42, 0xCC,
+	0x80, 0xC9, 0x32, 0x42, 0xCC, 0x81, 0xC9, 0x32,
+	0x42, 0xCC, 0x93, 0xC9, 0x32, 0x43, 0xE1, 0x85,
+	// Bytes 49c0 - 49ff
+	0xA1, 0x01, 0x00, 0x43, 0xE1, 0x85, 0xA2, 0x01,
+	0x00, 0x43, 0xE1, 0x85, 0xA3, 0x01, 0x00, 0x43,
+	0xE1, 0x85, 0xA4, 0x01, 0x00, 0x43, 0xE1, 0x85,
+	0xA5, 0x01, 0x00, 0x43, 0xE1, 0x85, 0xA6, 0x01,
+	0x00, 0x43, 0xE1, 0x85, 0xA7, 0x01, 0x00, 0x43,
+	0xE1, 0x85, 0xA8, 0x01, 0x00, 0x43, 0xE1, 0x85,
+	0xA9, 0x01, 0x00, 0x43, 0xE1, 0x85, 0xAA, 0x01,
+	0x00, 0x43, 0xE1, 0x85, 0xAB, 0x01, 0x00, 0x43,
+	// Bytes 4a00 - 4a3f
+	0xE1, 0x85, 0xAC, 0x01, 0x00, 0x43, 0xE1, 0x85,
+	0xAD, 0x01, 0x00, 0x43, 0xE1, 0x85, 0xAE, 0x01,
+	0x00, 0x43, 0xE1, 0x85, 0xAF, 0x01, 0x00, 0x43,
+	0xE1, 0x85, 0xB0, 0x01, 0x00, 0x43, 0xE1, 0x85,
+	0xB1, 0x01, 0x00, 0x43, 0xE1, 0x85, 0xB2, 0x01,
+	0x00, 0x43, 0xE1, 0x85, 0xB3, 0x01, 0x00, 0x43,
+	0xE1, 0x85, 0xB4, 0x01, 0x00, 0x43, 0xE1, 0x85,
+	0xB5, 0x01, 0x00, 0x43, 0xE1, 0x86, 0xAA, 0x01,
+	// Bytes 4a40 - 4a7f
+	0x00, 0x43, 0xE1, 0x86, 0xAC, 0x01, 0x00, 0x43,
+	0xE1, 0x86, 0xAD, 0x01, 0x00, 0x43, 0xE1, 0x86,
+	0xB0, 0x01, 0x00, 0x43, 0xE1, 0x86, 0xB1, 0x01,
+	0x00, 0x43, 0xE1, 0x86, 0xB2, 0x01, 0x00, 0x43,
+	0xE1, 0x86, 0xB3, 0x01, 0x00, 0x43, 0xE1, 0x86,
+	0xB4, 0x01, 0x00, 0x43, 0xE1, 0x86, 0xB5, 0x01,
+	0x00, 0x44, 0xCC, 0x88, 0xCC, 0x81, 0xCA, 0x32,
+	0x43, 0xE3, 0x82, 0x99, 0x0D, 0x03, 0x43, 0xE3,
+	// Bytes 4a80 - 4abf
+	0x82, 0x9A, 0x0D, 0x03, 0x46, 0xE0, 0xBD, 0xB1,
+	0xE0, 0xBD, 0xB2, 0x9E, 0x26, 0x46, 0xE0, 0xBD,
+	0xB1, 0xE0, 0xBD, 0xB4, 0xA2, 0x26, 0x46, 0xE0,
+	0xBD, 0xB1, 0xE0, 0xBE, 0x80, 0x9E, 0x26, 0x00,
+	0x01,
+}
+
+// lookup returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *nfcTrie) lookup(s []byte) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return nfcValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = nfcIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *nfcTrie) lookupUnsafe(s []byte) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return nfcValues[c0]
+	}
+	i := nfcIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = nfcIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = nfcIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// lookupString returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *nfcTrie) lookupString(s string) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return nfcValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := nfcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = nfcIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *nfcTrie) lookupStringUnsafe(s string) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return nfcValues[c0]
+	}
+	i := nfcIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = nfcIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = nfcIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// nfcTrie. Total size: 10442 bytes (10.20 KiB). Checksum: 4ba400a9d8208e03.
+type nfcTrie struct{}
+
+func newNfcTrie(i int) *nfcTrie {
+	return &nfcTrie{}
+}
+
+// lookupValue determines the type of block n and looks up the value for b.
+func (t *nfcTrie) lookupValue(n uint32, b byte) uint16 {
+	switch {
+	case n < 45:
+		return uint16(nfcValues[n<<6+uint32(b)])
+	default:
+		n -= 45
+		return uint16(nfcSparse.lookup(n, b))
+	}
+}
+
+// nfcValues: 47 blocks, 3008 entries, 6016 bytes
+// The third block is the zero block.
+var nfcValues = [3008]uint16{
+	// Block 0x0, offset 0x0
+	0x3c: 0xa000, 0x3d: 0xa000, 0x3e: 0xa000,
+	// Block 0x1, offset 0x40
+	0x41: 0xa000, 0x42: 0xa000, 0x43: 0xa000, 0x44: 0xa000, 0x45: 0xa000,
+	0x46: 0xa000, 0x47: 0xa000, 0x48: 0xa000, 0x49: 0xa000, 0x4a: 0xa000, 0x4b: 0xa000,
+	0x4c: 0xa000, 0x4d: 0xa000, 0x4e: 0xa000, 0x4f: 0xa000, 0x50: 0xa000,
+	0x52: 0xa000, 0x53: 0xa000, 0x54: 0xa000, 0x55: 0xa000, 0x56: 0xa000, 0x57: 0xa000,
+	0x58: 0xa000, 0x59: 0xa000, 0x5a: 0xa000,
+	0x61: 0xa000, 0x62: 0xa000, 0x63: 0xa000,
+	0x64: 0xa000, 0x65: 0xa000, 0x66: 0xa000, 0x67: 0xa000, 0x68: 0xa000, 0x69: 0xa000,
+	0x6a: 0xa000, 0x6b: 0xa000, 0x6c: 0xa000, 0x6d: 0xa000, 0x6e: 0xa000, 0x6f: 0xa000,
+	0x70: 0xa000, 0x72: 0xa000, 0x73: 0xa000, 0x74: 0xa000, 0x75: 0xa000,
+	0x76: 0xa000, 0x77: 0xa000, 0x78: 0xa000, 0x79: 0xa000, 0x7a: 0xa000,
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc0: 0x2f6f, 0xc1: 0x2f74, 0xc2: 0x4688, 0xc3: 0x2f79, 0xc4: 0x4697, 0xc5: 0x469c,
+	0xc6: 0xa000, 0xc7: 0x46a6, 0xc8: 0x2fe2, 0xc9: 0x2fe7, 0xca: 0x46ab, 0xcb: 0x2ffb,
+	0xcc: 0x306e, 0xcd: 0x3073, 0xce: 0x3078, 0xcf: 0x46bf, 0xd1: 0x3104,
+	0xd2: 0x3127, 0xd3: 0x312c, 0xd4: 0x46c9, 0xd5: 0x46ce, 0xd6: 0x46dd,
+	0xd8: 0xa000, 0xd9: 0x31b3, 0xda: 0x31b8, 0xdb: 0x31bd, 0xdc: 0x470f, 0xdd: 0x3235,
+	0xe0: 0x327b, 0xe1: 0x3280, 0xe2: 0x4719, 0xe3: 0x3285,
+	0xe4: 0x4728, 0xe5: 0x472d, 0xe6: 0xa000, 0xe7: 0x4737, 0xe8: 0x32ee, 0xe9: 0x32f3,
+	0xea: 0x473c, 0xeb: 0x3307, 0xec: 0x337f, 0xed: 0x3384, 0xee: 0x3389, 0xef: 0x4750,
+	0xf1: 0x3415, 0xf2: 0x3438, 0xf3: 0x343d, 0xf4: 0x475a, 0xf5: 0x475f,
+	0xf6: 0x476e, 0xf8: 0xa000, 0xf9: 0x34c9, 0xfa: 0x34ce, 0xfb: 0x34d3,
+	0xfc: 0x47a0, 0xfd: 0x3550, 0xff: 0x3569,
+	// Block 0x4, offset 0x100
+	0x100: 0x2f7e, 0x101: 0x328a, 0x102: 0x468d, 0x103: 0x471e, 0x104: 0x2f9c, 0x105: 0x32a8,
+	0x106: 0x2fb0, 0x107: 0x32bc, 0x108: 0x2fb5, 0x109: 0x32c1, 0x10a: 0x2fba, 0x10b: 0x32c6,
+	0x10c: 0x2fbf, 0x10d: 0x32cb, 0x10e: 0x2fc9, 0x10f: 0x32d5,
+	0x112: 0x46b0, 0x113: 0x4741, 0x114: 0x2ff1, 0x115: 0x32fd, 0x116: 0x2ff6, 0x117: 0x3302,
+	0x118: 0x3014, 0x119: 0x3320, 0x11a: 0x3005, 0x11b: 0x3311, 0x11c: 0x302d, 0x11d: 0x3339,
+	0x11e: 0x3037, 0x11f: 0x3343, 0x120: 0x303c, 0x121: 0x3348, 0x122: 0x3046, 0x123: 0x3352,
+	0x124: 0x304b, 0x125: 0x3357, 0x128: 0x307d, 0x129: 0x338e,
+	0x12a: 0x3082, 0x12b: 0x3393, 0x12c: 0x3087, 0x12d: 0x3398, 0x12e: 0x30aa, 0x12f: 0x33b6,
+	0x130: 0x308c, 0x134: 0x30b4, 0x135: 0x33c0,
+	0x136: 0x30c8, 0x137: 0x33d9, 0x139: 0x30d2, 0x13a: 0x33e3, 0x13b: 0x30dc,
+	0x13c: 0x33ed, 0x13d: 0x30d7, 0x13e: 0x33e8,
+	// Block 0x5, offset 0x140
+	0x143: 0x30ff, 0x144: 0x3410, 0x145: 0x3118,
+	0x146: 0x3429, 0x147: 0x310e, 0x148: 0x341f,
+	0x14c: 0x46d3, 0x14d: 0x4764, 0x14e: 0x3131, 0x14f: 0x3442, 0x150: 0x313b, 0x151: 0x344c,
+	0x154: 0x3159, 0x155: 0x346a, 0x156: 0x3172, 0x157: 0x3483,
+	0x158: 0x3163, 0x159: 0x3474, 0x15a: 0x46f6, 0x15b: 0x4787, 0x15c: 0x317c, 0x15d: 0x348d,
+	0x15e: 0x318b, 0x15f: 0x349c, 0x160: 0x46fb, 0x161: 0x478c, 0x162: 0x31a4, 0x163: 0x34ba,
+	0x164: 0x3195, 0x165: 0x34ab, 0x168: 0x4705, 0x169: 0x4796,
+	0x16a: 0x470a, 0x16b: 0x479b, 0x16c: 0x31c2, 0x16d: 0x34d8, 0x16e: 0x31cc, 0x16f: 0x34e2,
+	0x170: 0x31d1, 0x171: 0x34e7, 0x172: 0x31ef, 0x173: 0x3505, 0x174: 0x3212, 0x175: 0x3528,
+	0x176: 0x323a, 0x177: 0x3555, 0x178: 0x324e, 0x179: 0x325d, 0x17a: 0x357d, 0x17b: 0x3267,
+	0x17c: 0x3587, 0x17d: 0x326c, 0x17e: 0x358c, 0x17f: 0xa000,
+	// Block 0x6, offset 0x180
+	0x184: 0x8100, 0x185: 0x8100,
+	0x186: 0x8100,
+	0x18d: 0x2f88, 0x18e: 0x3294, 0x18f: 0x3096, 0x190: 0x33a2, 0x191: 0x3140,
+	0x192: 0x3451, 0x193: 0x31d6, 0x194: 0x34ec, 0x195: 0x39cf, 0x196: 0x3b5e, 0x197: 0x39c8,
+	0x198: 0x3b57, 0x199: 0x39d6, 0x19a: 0x3b65, 0x19b: 0x39c1, 0x19c: 0x3b50,
+	0x19e: 0x38b0, 0x19f: 0x3a3f, 0x1a0: 0x38a9, 0x1a1: 0x3a38, 0x1a2: 0x35b3, 0x1a3: 0x35c5,
+	0x1a6: 0x3041, 0x1a7: 0x334d, 0x1a8: 0x30be, 0x1a9: 0x33cf,
+	0x1aa: 0x46ec, 0x1ab: 0x477d, 0x1ac: 0x3990, 0x1ad: 0x3b1f, 0x1ae: 0x35d7, 0x1af: 0x35dd,
+	0x1b0: 0x33c5, 0x1b4: 0x3028, 0x1b5: 0x3334,
+	0x1b8: 0x30fa, 0x1b9: 0x340b, 0x1ba: 0x38b7, 0x1bb: 0x3a46,
+	0x1bc: 0x35ad, 0x1bd: 0x35bf, 0x1be: 0x35b9, 0x1bf: 0x35cb,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x2f8d, 0x1c1: 0x3299, 0x1c2: 0x2f92, 0x1c3: 0x329e, 0x1c4: 0x300a, 0x1c5: 0x3316,
+	0x1c6: 0x300f, 0x1c7: 0x331b, 0x1c8: 0x309b, 0x1c9: 0x33a7, 0x1ca: 0x30a0, 0x1cb: 0x33ac,
+	0x1cc: 0x3145, 0x1cd: 0x3456, 0x1ce: 0x314a, 0x1cf: 0x345b, 0x1d0: 0x3168, 0x1d1: 0x3479,
+	0x1d2: 0x316d, 0x1d3: 0x347e, 0x1d4: 0x31db, 0x1d5: 0x34f1, 0x1d6: 0x31e0, 0x1d7: 0x34f6,
+	0x1d8: 0x3186, 0x1d9: 0x3497, 0x1da: 0x319f, 0x1db: 0x34b5,
+	0x1de: 0x305a, 0x1df: 0x3366,
+	0x1e6: 0x4692, 0x1e7: 0x4723, 0x1e8: 0x46ba, 0x1e9: 0x474b,
+	0x1ea: 0x395f, 0x1eb: 0x3aee, 0x1ec: 0x393c, 0x1ed: 0x3acb, 0x1ee: 0x46d8, 0x1ef: 0x4769,
+	0x1f0: 0x3958, 0x1f1: 0x3ae7, 0x1f2: 0x3244, 0x1f3: 0x355f,
+	// Block 0x8, offset 0x200
+	0x200: 0x9932, 0x201: 0x9932, 0x202: 0x9932, 0x203: 0x9932, 0x204: 0x9932, 0x205: 0x8132,
+	0x206: 0x9932, 0x207: 0x9932, 0x208: 0x9932, 0x209: 0x9932, 0x20a: 0x9932, 0x20b: 0x9932,
+	0x20c: 0x9932, 0x20d: 0x8132, 0x20e: 0x8132, 0x20f: 0x9932, 0x210: 0x8132, 0x211: 0x9932,
+	0x212: 0x8132, 0x213: 0x9932, 0x214: 0x9932, 0x215: 0x8133, 0x216: 0x812d, 0x217: 0x812d,
+	0x218: 0x812d, 0x219: 0x812d, 0x21a: 0x8133, 0x21b: 0x992b, 0x21c: 0x812d, 0x21d: 0x812d,
+	0x21e: 0x812d, 0x21f: 0x812d, 0x220: 0x812d, 0x221: 0x8129, 0x222: 0x8129, 0x223: 0x992d,
+	0x224: 0x992d, 0x225: 0x992d, 0x226: 0x992d, 0x227: 0x9929, 0x228: 0x9929, 0x229: 0x812d,
+	0x22a: 0x812d, 0x22b: 0x812d, 0x22c: 0x812d, 0x22d: 0x992d, 0x22e: 0x992d, 0x22f: 0x812d,
+	0x230: 0x992d, 0x231: 0x992d, 0x232: 0x812d, 0x233: 0x812d, 0x234: 0x8101, 0x235: 0x8101,
+	0x236: 0x8101, 0x237: 0x8101, 0x238: 0x9901, 0x239: 0x812d, 0x23a: 0x812d, 0x23b: 0x812d,
+	0x23c: 0x812d, 0x23d: 0x8132, 0x23e: 0x8132, 0x23f: 0x8132,
+	// Block 0x9, offset 0x240
+	0x240: 0x49ae, 0x241: 0x49b3, 0x242: 0x9932, 0x243: 0x49b8, 0x244: 0x4a71, 0x245: 0x9936,
+	0x246: 0x8132, 0x247: 0x812d, 0x248: 0x812d, 0x249: 0x812d, 0x24a: 0x8132, 0x24b: 0x8132,
+	0x24c: 0x8132, 0x24d: 0x812d, 0x24e: 0x812d, 0x250: 0x8132, 0x251: 0x8132,
+	0x252: 0x8132, 0x253: 0x812d, 0x254: 0x812d, 0x255: 0x812d, 0x256: 0x812d, 0x257: 0x8132,
+	0x258: 0x8133, 0x259: 0x812d, 0x25a: 0x812d, 0x25b: 0x8132, 0x25c: 0x8134, 0x25d: 0x8135,
+	0x25e: 0x8135, 0x25f: 0x8134, 0x260: 0x8135, 0x261: 0x8135, 0x262: 0x8134, 0x263: 0x8132,
+	0x264: 0x8132, 0x265: 0x8132, 0x266: 0x8132, 0x267: 0x8132, 0x268: 0x8132, 0x269: 0x8132,
+	0x26a: 0x8132, 0x26b: 0x8132, 0x26c: 0x8132, 0x26d: 0x8132, 0x26e: 0x8132, 0x26f: 0x8132,
+	0x274: 0x0170,
+	0x27a: 0x8100,
+	0x27e: 0x0037,
+	// Block 0xa, offset 0x280
+	0x284: 0x8100, 0x285: 0x35a1,
+	0x286: 0x35e9, 0x287: 0x00ce, 0x288: 0x3607, 0x289: 0x3613, 0x28a: 0x3625,
+	0x28c: 0x3643, 0x28e: 0x3655, 0x28f: 0x3673, 0x290: 0x3e08, 0x291: 0xa000,
+	0x295: 0xa000, 0x297: 0xa000,
+	0x299: 0xa000,
+	0x29f: 0xa000, 0x2a1: 0xa000,
+	0x2a5: 0xa000, 0x2a9: 0xa000,
+	0x2aa: 0x3637, 0x2ab: 0x3667, 0x2ac: 0x47fe, 0x2ad: 0x3697, 0x2ae: 0x4828, 0x2af: 0x36a9,
+	0x2b0: 0x3e70, 0x2b1: 0xa000, 0x2b5: 0xa000,
+	0x2b7: 0xa000, 0x2b9: 0xa000,
+	0x2bf: 0xa000,
+	// Block 0xb, offset 0x2c0
+	0x2c0: 0x3721, 0x2c1: 0x372d, 0x2c3: 0x371b,
+	0x2c6: 0xa000, 0x2c7: 0x3709,
+	0x2cc: 0x375d, 0x2cd: 0x3745, 0x2ce: 0x376f, 0x2d0: 0xa000,
+	0x2d3: 0xa000, 0x2d5: 0xa000, 0x2d6: 0xa000, 0x2d7: 0xa000,
+	0x2d8: 0xa000, 0x2d9: 0x3751, 0x2da: 0xa000,
+	0x2de: 0xa000, 0x2e3: 0xa000,
+	0x2e7: 0xa000,
+	0x2eb: 0xa000, 0x2ed: 0xa000,
+	0x2f0: 0xa000, 0x2f3: 0xa000, 0x2f5: 0xa000,
+	0x2f6: 0xa000, 0x2f7: 0xa000, 0x2f8: 0xa000, 0x2f9: 0x37d5, 0x2fa: 0xa000,
+	0x2fe: 0xa000,
+	// Block 0xc, offset 0x300
+	0x301: 0x3733, 0x302: 0x37b7,
+	0x310: 0x370f, 0x311: 0x3793,
+	0x312: 0x3715, 0x313: 0x3799, 0x316: 0x3727, 0x317: 0x37ab,
+	0x318: 0xa000, 0x319: 0xa000, 0x31a: 0x3829, 0x31b: 0x382f, 0x31c: 0x3739, 0x31d: 0x37bd,
+	0x31e: 0x373f, 0x31f: 0x37c3, 0x322: 0x374b, 0x323: 0x37cf,
+	0x324: 0x3757, 0x325: 0x37db, 0x326: 0x3763, 0x327: 0x37e7, 0x328: 0xa000, 0x329: 0xa000,
+	0x32a: 0x3835, 0x32b: 0x383b, 0x32c: 0x378d, 0x32d: 0x3811, 0x32e: 0x3769, 0x32f: 0x37ed,
+	0x330: 0x3775, 0x331: 0x37f9, 0x332: 0x377b, 0x333: 0x37ff, 0x334: 0x3781, 0x335: 0x3805,
+	0x338: 0x3787, 0x339: 0x380b,
+	// Block 0xd, offset 0x340
+	0x351: 0x812d,
+	0x352: 0x8132, 0x353: 0x8132, 0x354: 0x8132, 0x355: 0x8132, 0x356: 0x812d, 0x357: 0x8132,
+	0x358: 0x8132, 0x359: 0x8132, 0x35a: 0x812e, 0x35b: 0x812d, 0x35c: 0x8132, 0x35d: 0x8132,
+	0x35e: 0x8132, 0x35f: 0x8132, 0x360: 0x8132, 0x361: 0x8132, 0x362: 0x812d, 0x363: 0x812d,
+	0x364: 0x812d, 0x365: 0x812d, 0x366: 0x812d, 0x367: 0x812d, 0x368: 0x8132, 0x369: 0x8132,
+	0x36a: 0x812d, 0x36b: 0x8132, 0x36c: 0x8132, 0x36d: 0x812e, 0x36e: 0x8131, 0x36f: 0x8132,
+	0x370: 0x8105, 0x371: 0x8106, 0x372: 0x8107, 0x373: 0x8108, 0x374: 0x8109, 0x375: 0x810a,
+	0x376: 0x810b, 0x377: 0x810c, 0x378: 0x810d, 0x379: 0x810e, 0x37a: 0x810e, 0x37b: 0x810f,
+	0x37c: 0x8110, 0x37d: 0x8111, 0x37f: 0x8112,
+	// Block 0xe, offset 0x380
+	0x388: 0xa000, 0x38a: 0xa000, 0x38b: 0x8116,
+	0x38c: 0x8117, 0x38d: 0x8118, 0x38e: 0x8119, 0x38f: 0x811a, 0x390: 0x811b, 0x391: 0x811c,
+	0x392: 0x811d, 0x393: 0x9932, 0x394: 0x9932, 0x395: 0x992d, 0x396: 0x812d, 0x397: 0x8132,
+	0x398: 0x8132, 0x399: 0x8132, 0x39a: 0x8132, 0x39b: 0x8132, 0x39c: 0x812d, 0x39d: 0x8132,
+	0x39e: 0x8132, 0x39f: 0x812d,
+	0x3b0: 0x811e,
+	// Block 0xf, offset 0x3c0
+	0x3c5: 0xa000,
+	0x3c6: 0x2d26, 0x3c7: 0xa000, 0x3c8: 0x2d2e, 0x3c9: 0xa000, 0x3ca: 0x2d36, 0x3cb: 0xa000,
+	0x3cc: 0x2d3e, 0x3cd: 0xa000, 0x3ce: 0x2d46, 0x3d1: 0xa000,
+	0x3d2: 0x2d4e,
+	0x3f4: 0x8102, 0x3f5: 0x9900,
+	0x3fa: 0xa000, 0x3fb: 0x2d56,
+	0x3fc: 0xa000, 0x3fd: 0x2d5e, 0x3fe: 0xa000, 0x3ff: 0xa000,
+	// Block 0x10, offset 0x400
+	0x400: 0x8132, 0x401: 0x8132, 0x402: 0x812d, 0x403: 0x8132, 0x404: 0x8132, 0x405: 0x8132,
+	0x406: 0x8132, 0x407: 0x8132, 0x408: 0x8132, 0x409: 0x8132, 0x40a: 0x812d, 0x40b: 0x8132,
+	0x40c: 0x8132, 0x40d: 0x8135, 0x40e: 0x812a, 0x40f: 0x812d, 0x410: 0x8129, 0x411: 0x8132,
+	0x412: 0x8132, 0x413: 0x8132, 0x414: 0x8132, 0x415: 0x8132, 0x416: 0x8132, 0x417: 0x8132,
+	0x418: 0x8132, 0x419: 0x8132, 0x41a: 0x8132, 0x41b: 0x8132, 0x41c: 0x8132, 0x41d: 0x8132,
+	0x41e: 0x8132, 0x41f: 0x8132, 0x420: 0x8132, 0x421: 0x8132, 0x422: 0x8132, 0x423: 0x8132,
+	0x424: 0x8132, 0x425: 0x8132, 0x426: 0x8132, 0x427: 0x8132, 0x428: 0x8132, 0x429: 0x8132,
+	0x42a: 0x8132, 0x42b: 0x8132, 0x42c: 0x8132, 0x42d: 0x8132, 0x42e: 0x8132, 0x42f: 0x8132,
+	0x430: 0x8132, 0x431: 0x8132, 0x432: 0x8132, 0x433: 0x8132, 0x434: 0x8132, 0x435: 0x8132,
+	0x436: 0x8133, 0x437: 0x8131, 0x438: 0x8131, 0x439: 0x812d, 0x43b: 0x8132,
+	0x43c: 0x8134, 0x43d: 0x812d, 0x43e: 0x8132, 0x43f: 0x812d,
+	// Block 0x11, offset 0x440
+	0x440: 0x2f97, 0x441: 0x32a3, 0x442: 0x2fa1, 0x443: 0x32ad, 0x444: 0x2fa6, 0x445: 0x32b2,
+	0x446: 0x2fab, 0x447: 0x32b7, 0x448: 0x38cc, 0x449: 0x3a5b, 0x44a: 0x2fc4, 0x44b: 0x32d0,
+	0x44c: 0x2fce, 0x44d: 0x32da, 0x44e: 0x2fdd, 0x44f: 0x32e9, 0x450: 0x2fd3, 0x451: 0x32df,
+	0x452: 0x2fd8, 0x453: 0x32e4, 0x454: 0x38ef, 0x455: 0x3a7e, 0x456: 0x38f6, 0x457: 0x3a85,
+	0x458: 0x3019, 0x459: 0x3325, 0x45a: 0x301e, 0x45b: 0x332a, 0x45c: 0x3904, 0x45d: 0x3a93,
+	0x45e: 0x3023, 0x45f: 0x332f, 0x460: 0x3032, 0x461: 0x333e, 0x462: 0x3050, 0x463: 0x335c,
+	0x464: 0x305f, 0x465: 0x336b, 0x466: 0x3055, 0x467: 0x3361, 0x468: 0x3064, 0x469: 0x3370,
+	0x46a: 0x3069, 0x46b: 0x3375, 0x46c: 0x30af, 0x46d: 0x33bb, 0x46e: 0x390b, 0x46f: 0x3a9a,
+	0x470: 0x30b9, 0x471: 0x33ca, 0x472: 0x30c3, 0x473: 0x33d4, 0x474: 0x30cd, 0x475: 0x33de,
+	0x476: 0x46c4, 0x477: 0x4755, 0x478: 0x3912, 0x479: 0x3aa1, 0x47a: 0x30e6, 0x47b: 0x33f7,
+	0x47c: 0x30e1, 0x47d: 0x33f2, 0x47e: 0x30eb, 0x47f: 0x33fc,
+	// Block 0x12, offset 0x480
+	0x480: 0x30f0, 0x481: 0x3401, 0x482: 0x30f5, 0x483: 0x3406, 0x484: 0x3109, 0x485: 0x341a,
+	0x486: 0x3113, 0x487: 0x3424, 0x488: 0x3122, 0x489: 0x3433, 0x48a: 0x311d, 0x48b: 0x342e,
+	0x48c: 0x3935, 0x48d: 0x3ac4, 0x48e: 0x3943, 0x48f: 0x3ad2, 0x490: 0x394a, 0x491: 0x3ad9,
+	0x492: 0x3951, 0x493: 0x3ae0, 0x494: 0x314f, 0x495: 0x3460, 0x496: 0x3154, 0x497: 0x3465,
+	0x498: 0x315e, 0x499: 0x346f, 0x49a: 0x46f1, 0x49b: 0x4782, 0x49c: 0x3997, 0x49d: 0x3b26,
+	0x49e: 0x3177, 0x49f: 0x3488, 0x4a0: 0x3181, 0x4a1: 0x3492, 0x4a2: 0x4700, 0x4a3: 0x4791,
+	0x4a4: 0x399e, 0x4a5: 0x3b2d, 0x4a6: 0x39a5, 0x4a7: 0x3b34, 0x4a8: 0x39ac, 0x4a9: 0x3b3b,
+	0x4aa: 0x3190, 0x4ab: 0x34a1, 0x4ac: 0x319a, 0x4ad: 0x34b0, 0x4ae: 0x31ae, 0x4af: 0x34c4,
+	0x4b0: 0x31a9, 0x4b1: 0x34bf, 0x4b2: 0x31ea, 0x4b3: 0x3500, 0x4b4: 0x31f9, 0x4b5: 0x350f,
+	0x4b6: 0x31f4, 0x4b7: 0x350a, 0x4b8: 0x39b3, 0x4b9: 0x3b42, 0x4ba: 0x39ba, 0x4bb: 0x3b49,
+	0x4bc: 0x31fe, 0x4bd: 0x3514, 0x4be: 0x3203, 0x4bf: 0x3519,
+	// Block 0x13, offset 0x4c0
+	0x4c0: 0x3208, 0x4c1: 0x351e, 0x4c2: 0x320d, 0x4c3: 0x3523, 0x4c4: 0x321c, 0x4c5: 0x3532,
+	0x4c6: 0x3217, 0x4c7: 0x352d, 0x4c8: 0x3221, 0x4c9: 0x353c, 0x4ca: 0x3226, 0x4cb: 0x3541,
+	0x4cc: 0x322b, 0x4cd: 0x3546, 0x4ce: 0x3249, 0x4cf: 0x3564, 0x4d0: 0x3262, 0x4d1: 0x3582,
+	0x4d2: 0x3271, 0x4d3: 0x3591, 0x4d4: 0x3276, 0x4d5: 0x3596, 0x4d6: 0x337a, 0x4d7: 0x34a6,
+	0x4d8: 0x3537, 0x4d9: 0x3573, 0x4db: 0x35d1,
+	0x4e0: 0x46a1, 0x4e1: 0x4732, 0x4e2: 0x2f83, 0x4e3: 0x328f,
+	0x4e4: 0x3878, 0x4e5: 0x3a07, 0x4e6: 0x3871, 0x4e7: 0x3a00, 0x4e8: 0x3886, 0x4e9: 0x3a15,
+	0x4ea: 0x387f, 0x4eb: 0x3a0e, 0x4ec: 0x38be, 0x4ed: 0x3a4d, 0x4ee: 0x3894, 0x4ef: 0x3a23,
+	0x4f0: 0x388d, 0x4f1: 0x3a1c, 0x4f2: 0x38a2, 0x4f3: 0x3a31, 0x4f4: 0x389b, 0x4f5: 0x3a2a,
+	0x4f6: 0x38c5, 0x4f7: 0x3a54, 0x4f8: 0x46b5, 0x4f9: 0x4746, 0x4fa: 0x3000, 0x4fb: 0x330c,
+	0x4fc: 0x2fec, 0x4fd: 0x32f8, 0x4fe: 0x38da, 0x4ff: 0x3a69,
+	// Block 0x14, offset 0x500
+	0x500: 0x38d3, 0x501: 0x3a62, 0x502: 0x38e8, 0x503: 0x3a77, 0x504: 0x38e1, 0x505: 0x3a70,
+	0x506: 0x38fd, 0x507: 0x3a8c, 0x508: 0x3091, 0x509: 0x339d, 0x50a: 0x30a5, 0x50b: 0x33b1,
+	0x50c: 0x46e7, 0x50d: 0x4778, 0x50e: 0x3136, 0x50f: 0x3447, 0x510: 0x3920, 0x511: 0x3aaf,
+	0x512: 0x3919, 0x513: 0x3aa8, 0x514: 0x392e, 0x515: 0x3abd, 0x516: 0x3927, 0x517: 0x3ab6,
+	0x518: 0x3989, 0x519: 0x3b18, 0x51a: 0x396d, 0x51b: 0x3afc, 0x51c: 0x3966, 0x51d: 0x3af5,
+	0x51e: 0x397b, 0x51f: 0x3b0a, 0x520: 0x3974, 0x521: 0x3b03, 0x522: 0x3982, 0x523: 0x3b11,
+	0x524: 0x31e5, 0x525: 0x34fb, 0x526: 0x31c7, 0x527: 0x34dd, 0x528: 0x39e4, 0x529: 0x3b73,
+	0x52a: 0x39dd, 0x52b: 0x3b6c, 0x52c: 0x39f2, 0x52d: 0x3b81, 0x52e: 0x39eb, 0x52f: 0x3b7a,
+	0x530: 0x39f9, 0x531: 0x3b88, 0x532: 0x3230, 0x533: 0x354b, 0x534: 0x3258, 0x535: 0x3578,
+	0x536: 0x3253, 0x537: 0x356e, 0x538: 0x323f, 0x539: 0x355a,
+	// Block 0x15, offset 0x540
+	0x540: 0x4804, 0x541: 0x480a, 0x542: 0x491e, 0x543: 0x4936, 0x544: 0x4926, 0x545: 0x493e,
+	0x546: 0x492e, 0x547: 0x4946, 0x548: 0x47aa, 0x549: 0x47b0, 0x54a: 0x488e, 0x54b: 0x48a6,
+	0x54c: 0x4896, 0x54d: 0x48ae, 0x54e: 0x489e, 0x54f: 0x48b6, 0x550: 0x4816, 0x551: 0x481c,
+	0x552: 0x3db8, 0x553: 0x3dc8, 0x554: 0x3dc0, 0x555: 0x3dd0,
+	0x558: 0x47b6, 0x559: 0x47bc, 0x55a: 0x3ce8, 0x55b: 0x3cf8, 0x55c: 0x3cf0, 0x55d: 0x3d00,
+	0x560: 0x482e, 0x561: 0x4834, 0x562: 0x494e, 0x563: 0x4966,
+	0x564: 0x4956, 0x565: 0x496e, 0x566: 0x495e, 0x567: 0x4976, 0x568: 0x47c2, 0x569: 0x47c8,
+	0x56a: 0x48be, 0x56b: 0x48d6, 0x56c: 0x48c6, 0x56d: 0x48de, 0x56e: 0x48ce, 0x56f: 0x48e6,
+	0x570: 0x4846, 0x571: 0x484c, 0x572: 0x3e18, 0x573: 0x3e30, 0x574: 0x3e20, 0x575: 0x3e38,
+	0x576: 0x3e28, 0x577: 0x3e40, 0x578: 0x47ce, 0x579: 0x47d4, 0x57a: 0x3d18, 0x57b: 0x3d30,
+	0x57c: 0x3d20, 0x57d: 0x3d38, 0x57e: 0x3d28, 0x57f: 0x3d40,
+	// Block 0x16, offset 0x580
+	0x580: 0x4852, 0x581: 0x4858, 0x582: 0x3e48, 0x583: 0x3e58, 0x584: 0x3e50, 0x585: 0x3e60,
+	0x588: 0x47da, 0x589: 0x47e0, 0x58a: 0x3d48, 0x58b: 0x3d58,
+	0x58c: 0x3d50, 0x58d: 0x3d60, 0x590: 0x4864, 0x591: 0x486a,
+	0x592: 0x3e80, 0x593: 0x3e98, 0x594: 0x3e88, 0x595: 0x3ea0, 0x596: 0x3e90, 0x597: 0x3ea8,
+	0x599: 0x47e6, 0x59b: 0x3d68, 0x59d: 0x3d70,
+	0x59f: 0x3d78, 0x5a0: 0x487c, 0x5a1: 0x4882, 0x5a2: 0x497e, 0x5a3: 0x4996,
+	0x5a4: 0x4986, 0x5a5: 0x499e, 0x5a6: 0x498e, 0x5a7: 0x49a6, 0x5a8: 0x47ec, 0x5a9: 0x47f2,
+	0x5aa: 0x48ee, 0x5ab: 0x4906, 0x5ac: 0x48f6, 0x5ad: 0x490e, 0x5ae: 0x48fe, 0x5af: 0x4916,
+	0x5b0: 0x47f8, 0x5b1: 0x431e, 0x5b2: 0x3691, 0x5b3: 0x4324, 0x5b4: 0x4822, 0x5b5: 0x432a,
+	0x5b6: 0x36a3, 0x5b7: 0x4330, 0x5b8: 0x36c1, 0x5b9: 0x4336, 0x5ba: 0x36d9, 0x5bb: 0x433c,
+	0x5bc: 0x4870, 0x5bd: 0x4342,
+	// Block 0x17, offset 0x5c0
+	0x5c0: 0x3da0, 0x5c1: 0x3da8, 0x5c2: 0x4184, 0x5c3: 0x41a2, 0x5c4: 0x418e, 0x5c5: 0x41ac,
+	0x5c6: 0x4198, 0x5c7: 0x41b6, 0x5c8: 0x3cd8, 0x5c9: 0x3ce0, 0x5ca: 0x40d0, 0x5cb: 0x40ee,
+	0x5cc: 0x40da, 0x5cd: 0x40f8, 0x5ce: 0x40e4, 0x5cf: 0x4102, 0x5d0: 0x3de8, 0x5d1: 0x3df0,
+	0x5d2: 0x41c0, 0x5d3: 0x41de, 0x5d4: 0x41ca, 0x5d5: 0x41e8, 0x5d6: 0x41d4, 0x5d7: 0x41f2,
+	0x5d8: 0x3d08, 0x5d9: 0x3d10, 0x5da: 0x410c, 0x5db: 0x412a, 0x5dc: 0x4116, 0x5dd: 0x4134,
+	0x5de: 0x4120, 0x5df: 0x413e, 0x5e0: 0x3ec0, 0x5e1: 0x3ec8, 0x5e2: 0x41fc, 0x5e3: 0x421a,
+	0x5e4: 0x4206, 0x5e5: 0x4224, 0x5e6: 0x4210, 0x5e7: 0x422e, 0x5e8: 0x3d80, 0x5e9: 0x3d88,
+	0x5ea: 0x4148, 0x5eb: 0x4166, 0x5ec: 0x4152, 0x5ed: 0x4170, 0x5ee: 0x415c, 0x5ef: 0x417a,
+	0x5f0: 0x3685, 0x5f1: 0x367f, 0x5f2: 0x3d90, 0x5f3: 0x368b, 0x5f4: 0x3d98,
+	0x5f6: 0x4810, 0x5f7: 0x3db0, 0x5f8: 0x35f5, 0x5f9: 0x35ef, 0x5fa: 0x35e3, 0x5fb: 0x42ee,
+	0x5fc: 0x35fb, 0x5fd: 0x8100, 0x5fe: 0x01d3, 0x5ff: 0xa100,
+	// Block 0x18, offset 0x600
+	0x600: 0x8100, 0x601: 0x35a7, 0x602: 0x3dd8, 0x603: 0x369d, 0x604: 0x3de0,
+	0x606: 0x483a, 0x607: 0x3df8, 0x608: 0x3601, 0x609: 0x42f4, 0x60a: 0x360d, 0x60b: 0x42fa,
+	0x60c: 0x3619, 0x60d: 0x3b8f, 0x60e: 0x3b96, 0x60f: 0x3b9d, 0x610: 0x36b5, 0x611: 0x36af,
+	0x612: 0x3e00, 0x613: 0x44e4, 0x616: 0x36bb, 0x617: 0x3e10,
+	0x618: 0x3631, 0x619: 0x362b, 0x61a: 0x361f, 0x61b: 0x4300, 0x61d: 0x3ba4,
+	0x61e: 0x3bab, 0x61f: 0x3bb2, 0x620: 0x36eb, 0x621: 0x36e5, 0x622: 0x3e68, 0x623: 0x44ec,
+	0x624: 0x36cd, 0x625: 0x36d3, 0x626: 0x36f1, 0x627: 0x3e78, 0x628: 0x3661, 0x629: 0x365b,
+	0x62a: 0x364f, 0x62b: 0x430c, 0x62c: 0x3649, 0x62d: 0x359b, 0x62e: 0x42e8, 0x62f: 0x0081,
+	0x632: 0x3eb0, 0x633: 0x36f7, 0x634: 0x3eb8,
+	0x636: 0x4888, 0x637: 0x3ed0, 0x638: 0x363d, 0x639: 0x4306, 0x63a: 0x366d, 0x63b: 0x4318,
+	0x63c: 0x3679, 0x63d: 0x4256, 0x63e: 0xa100,
+	// Block 0x19, offset 0x640
+	0x641: 0x3c06, 0x643: 0xa000, 0x644: 0x3c0d, 0x645: 0xa000,
+	0x647: 0x3c14, 0x648: 0xa000, 0x649: 0x3c1b,
+	0x64d: 0xa000,
+	0x660: 0x2f65, 0x661: 0xa000, 0x662: 0x3c29,
+	0x664: 0xa000, 0x665: 0xa000,
+	0x66d: 0x3c22, 0x66e: 0x2f60, 0x66f: 0x2f6a,
+	0x670: 0x3c30, 0x671: 0x3c37, 0x672: 0xa000, 0x673: 0xa000, 0x674: 0x3c3e, 0x675: 0x3c45,
+	0x676: 0xa000, 0x677: 0xa000, 0x678: 0x3c4c, 0x679: 0x3c53, 0x67a: 0xa000, 0x67b: 0xa000,
+	0x67c: 0xa000, 0x67d: 0xa000,
+	// Block 0x1a, offset 0x680
+	0x680: 0x3c5a, 0x681: 0x3c61, 0x682: 0xa000, 0x683: 0xa000, 0x684: 0x3c76, 0x685: 0x3c7d,
+	0x686: 0xa000, 0x687: 0xa000, 0x688: 0x3c84, 0x689: 0x3c8b,
+	0x691: 0xa000,
+	0x692: 0xa000,
+	0x6a2: 0xa000,
+	0x6a8: 0xa000, 0x6a9: 0xa000,
+	0x6ab: 0xa000, 0x6ac: 0x3ca0, 0x6ad: 0x3ca7, 0x6ae: 0x3cae, 0x6af: 0x3cb5,
+	0x6b2: 0xa000, 0x6b3: 0xa000, 0x6b4: 0xa000, 0x6b5: 0xa000,
+	// Block 0x1b, offset 0x6c0
+	0x6c6: 0xa000, 0x6cb: 0xa000,
+	0x6cc: 0x3f08, 0x6cd: 0xa000, 0x6ce: 0x3f10, 0x6cf: 0xa000, 0x6d0: 0x3f18, 0x6d1: 0xa000,
+	0x6d2: 0x3f20, 0x6d3: 0xa000, 0x6d4: 0x3f28, 0x6d5: 0xa000, 0x6d6: 0x3f30, 0x6d7: 0xa000,
+	0x6d8: 0x3f38, 0x6d9: 0xa000, 0x6da: 0x3f40, 0x6db: 0xa000, 0x6dc: 0x3f48, 0x6dd: 0xa000,
+	0x6de: 0x3f50, 0x6df: 0xa000, 0x6e0: 0x3f58, 0x6e1: 0xa000, 0x6e2: 0x3f60,
+	0x6e4: 0xa000, 0x6e5: 0x3f68, 0x6e6: 0xa000, 0x6e7: 0x3f70, 0x6e8: 0xa000, 0x6e9: 0x3f78,
+	0x6ef: 0xa000,
+	0x6f0: 0x3f80, 0x6f1: 0x3f88, 0x6f2: 0xa000, 0x6f3: 0x3f90, 0x6f4: 0x3f98, 0x6f5: 0xa000,
+	0x6f6: 0x3fa0, 0x6f7: 0x3fa8, 0x6f8: 0xa000, 0x6f9: 0x3fb0, 0x6fa: 0x3fb8, 0x6fb: 0xa000,
+	0x6fc: 0x3fc0, 0x6fd: 0x3fc8,
+	// Block 0x1c, offset 0x700
+	0x714: 0x3f00,
+	0x719: 0x9903, 0x71a: 0x9903, 0x71b: 0x8100, 0x71c: 0x8100, 0x71d: 0xa000,
+	0x71e: 0x3fd0,
+	0x726: 0xa000,
+	0x72b: 0xa000, 0x72c: 0x3fe0, 0x72d: 0xa000, 0x72e: 0x3fe8, 0x72f: 0xa000,
+	0x730: 0x3ff0, 0x731: 0xa000, 0x732: 0x3ff8, 0x733: 0xa000, 0x734: 0x4000, 0x735: 0xa000,
+	0x736: 0x4008, 0x737: 0xa000, 0x738: 0x4010, 0x739: 0xa000, 0x73a: 0x4018, 0x73b: 0xa000,
+	0x73c: 0x4020, 0x73d: 0xa000, 0x73e: 0x4028, 0x73f: 0xa000,
+	// Block 0x1d, offset 0x740
+	0x740: 0x4030, 0x741: 0xa000, 0x742: 0x4038, 0x744: 0xa000, 0x745: 0x4040,
+	0x746: 0xa000, 0x747: 0x4048, 0x748: 0xa000, 0x749: 0x4050,
+	0x74f: 0xa000, 0x750: 0x4058, 0x751: 0x4060,
+	0x752: 0xa000, 0x753: 0x4068, 0x754: 0x4070, 0x755: 0xa000, 0x756: 0x4078, 0x757: 0x4080,
+	0x758: 0xa000, 0x759: 0x4088, 0x75a: 0x4090, 0x75b: 0xa000, 0x75c: 0x4098, 0x75d: 0x40a0,
+	0x76f: 0xa000,
+	0x770: 0xa000, 0x771: 0xa000, 0x772: 0xa000, 0x774: 0x3fd8,
+	0x777: 0x40a8, 0x778: 0x40b0, 0x779: 0x40b8, 0x77a: 0x40c0,
+	0x77d: 0xa000, 0x77e: 0x40c8,
+	// Block 0x1e, offset 0x780
+	0x780: 0x1377, 0x781: 0x0cfb, 0x782: 0x13d3, 0x783: 0x139f, 0x784: 0x0e57, 0x785: 0x06eb,
+	0x786: 0x08df, 0x787: 0x162b, 0x788: 0x162b, 0x789: 0x0a0b, 0x78a: 0x145f, 0x78b: 0x0943,
+	0x78c: 0x0a07, 0x78d: 0x0bef, 0x78e: 0x0fcf, 0x78f: 0x115f, 0x790: 0x1297, 0x791: 0x12d3,
+	0x792: 0x1307, 0x793: 0x141b, 0x794: 0x0d73, 0x795: 0x0dff, 0x796: 0x0eab, 0x797: 0x0f43,
+	0x798: 0x125f, 0x799: 0x1447, 0x79a: 0x1573, 0x79b: 0x070f, 0x79c: 0x08b3, 0x79d: 0x0d87,
+	0x79e: 0x0ecf, 0x79f: 0x1293, 0x7a0: 0x15c3, 0x7a1: 0x0ab3, 0x7a2: 0x0e77, 0x7a3: 0x1283,
+	0x7a4: 0x1317, 0x7a5: 0x0c23, 0x7a6: 0x11bb, 0x7a7: 0x12df, 0x7a8: 0x0b1f, 0x7a9: 0x0d0f,
+	0x7aa: 0x0e17, 0x7ab: 0x0f1b, 0x7ac: 0x1427, 0x7ad: 0x074f, 0x7ae: 0x07e7, 0x7af: 0x0853,
+	0x7b0: 0x0c8b, 0x7b1: 0x0d7f, 0x7b2: 0x0ecb, 0x7b3: 0x0fef, 0x7b4: 0x1177, 0x7b5: 0x128b,
+	0x7b6: 0x12a3, 0x7b7: 0x13c7, 0x7b8: 0x14ef, 0x7b9: 0x15a3, 0x7ba: 0x15bf, 0x7bb: 0x102b,
+	0x7bc: 0x106b, 0x7bd: 0x1123, 0x7be: 0x1243, 0x7bf: 0x147b,
+	// Block 0x1f, offset 0x7c0
+	0x7c0: 0x15cb, 0x7c1: 0x134b, 0x7c2: 0x09c7, 0x7c3: 0x0b3b, 0x7c4: 0x10db, 0x7c5: 0x119b,
+	0x7c6: 0x0eff, 0x7c7: 0x1033, 0x7c8: 0x1397, 0x7c9: 0x14e7, 0x7ca: 0x09c3, 0x7cb: 0x0a8f,
+	0x7cc: 0x0d77, 0x7cd: 0x0e2b, 0x7ce: 0x0e5f, 0x7cf: 0x1113, 0x7d0: 0x113b, 0x7d1: 0x14a7,
+	0x7d2: 0x084f, 0x7d3: 0x11a7, 0x7d4: 0x07f3, 0x7d5: 0x07ef, 0x7d6: 0x1097, 0x7d7: 0x1127,
+	0x7d8: 0x125b, 0x7d9: 0x14af, 0x7da: 0x1367, 0x7db: 0x0c27, 0x7dc: 0x0d73, 0x7dd: 0x1357,
+	0x7de: 0x06f7, 0x7df: 0x0a63, 0x7e0: 0x0b93, 0x7e1: 0x0f2f, 0x7e2: 0x0faf, 0x7e3: 0x0873,
+	0x7e4: 0x103b, 0x7e5: 0x075f, 0x7e6: 0x0b77, 0x7e7: 0x06d7, 0x7e8: 0x0deb, 0x7e9: 0x0ca3,
+	0x7ea: 0x110f, 0x7eb: 0x08c7, 0x7ec: 0x09b3, 0x7ed: 0x0ffb, 0x7ee: 0x1263, 0x7ef: 0x133b,
+	0x7f0: 0x0db7, 0x7f1: 0x13f7, 0x7f2: 0x0de3, 0x7f3: 0x0c37, 0x7f4: 0x121b, 0x7f5: 0x0c57,
+	0x7f6: 0x0fab, 0x7f7: 0x072b, 0x7f8: 0x07a7, 0x7f9: 0x07eb, 0x7fa: 0x0d53, 0x7fb: 0x10fb,
+	0x7fc: 0x11f3, 0x7fd: 0x1347, 0x7fe: 0x145b, 0x7ff: 0x085b,
+	// Block 0x20, offset 0x800
+	0x800: 0x090f, 0x801: 0x0a17, 0x802: 0x0b2f, 0x803: 0x0cbf, 0x804: 0x0e7b, 0x805: 0x103f,
+	0x806: 0x1497, 0x807: 0x157b, 0x808: 0x15cf, 0x809: 0x15e7, 0x80a: 0x0837, 0x80b: 0x0cf3,
+	0x80c: 0x0da3, 0x80d: 0x13eb, 0x80e: 0x0afb, 0x80f: 0x0bd7, 0x810: 0x0bf3, 0x811: 0x0c83,
+	0x812: 0x0e6b, 0x813: 0x0eb7, 0x814: 0x0f67, 0x815: 0x108b, 0x816: 0x112f, 0x817: 0x1193,
+	0x818: 0x13db, 0x819: 0x126b, 0x81a: 0x1403, 0x81b: 0x147f, 0x81c: 0x080f, 0x81d: 0x083b,
+	0x81e: 0x0923, 0x81f: 0x0ea7, 0x820: 0x12f3, 0x821: 0x133b, 0x822: 0x0b1b, 0x823: 0x0b8b,
+	0x824: 0x0c4f, 0x825: 0x0daf, 0x826: 0x10d7, 0x827: 0x0f23, 0x828: 0x073b, 0x829: 0x097f,
+	0x82a: 0x0a63, 0x82b: 0x0ac7, 0x82c: 0x0b97, 0x82d: 0x0f3f, 0x82e: 0x0f5b, 0x82f: 0x116b,
+	0x830: 0x118b, 0x831: 0x1463, 0x832: 0x14e3, 0x833: 0x14f3, 0x834: 0x152f, 0x835: 0x0753,
+	0x836: 0x107f, 0x837: 0x144f, 0x838: 0x14cb, 0x839: 0x0baf, 0x83a: 0x0717, 0x83b: 0x0777,
+	0x83c: 0x0a67, 0x83d: 0x0a87, 0x83e: 0x0caf, 0x83f: 0x0d73,
+	// Block 0x21, offset 0x840
+	0x840: 0x0ec3, 0x841: 0x0fcb, 0x842: 0x1277, 0x843: 0x1417, 0x844: 0x1623, 0x845: 0x0ce3,
+	0x846: 0x14a3, 0x847: 0x0833, 0x848: 0x0d2f, 0x849: 0x0d3b, 0x84a: 0x0e0f, 0x84b: 0x0e47,
+	0x84c: 0x0f4b, 0x84d: 0x0fa7, 0x84e: 0x1027, 0x84f: 0x110b, 0x850: 0x153b, 0x851: 0x07af,
+	0x852: 0x0c03, 0x853: 0x14b3, 0x854: 0x0767, 0x855: 0x0aab, 0x856: 0x0e2f, 0x857: 0x13df,
+	0x858: 0x0b67, 0x859: 0x0bb7, 0x85a: 0x0d43, 0x85b: 0x0f2f, 0x85c: 0x14bb, 0x85d: 0x0817,
+	0x85e: 0x08ff, 0x85f: 0x0a97, 0x860: 0x0cd3, 0x861: 0x0d1f, 0x862: 0x0d5f, 0x863: 0x0df3,
+	0x864: 0x0f47, 0x865: 0x0fbb, 0x866: 0x1157, 0x867: 0x12f7, 0x868: 0x1303, 0x869: 0x1457,
+	0x86a: 0x14d7, 0x86b: 0x0883, 0x86c: 0x0e4b, 0x86d: 0x0903, 0x86e: 0x0ec7, 0x86f: 0x0f6b,
+	0x870: 0x1287, 0x871: 0x14bf, 0x872: 0x15ab, 0x873: 0x15d3, 0x874: 0x0d37, 0x875: 0x0e27,
+	0x876: 0x11c3, 0x877: 0x10b7, 0x878: 0x10c3, 0x879: 0x10e7, 0x87a: 0x0f17, 0x87b: 0x0e9f,
+	0x87c: 0x1363, 0x87d: 0x0733, 0x87e: 0x122b, 0x87f: 0x081b,
+	// Block 0x22, offset 0x880
+	0x880: 0x080b, 0x881: 0x0b0b, 0x882: 0x0c2b, 0x883: 0x10f3, 0x884: 0x0a53, 0x885: 0x0e03,
+	0x886: 0x0cef, 0x887: 0x13e7, 0x888: 0x12e7, 0x889: 0x14ab, 0x88a: 0x1323, 0x88b: 0x0b27,
+	0x88c: 0x0787, 0x88d: 0x095b, 0x890: 0x09af,
+	0x892: 0x0cdf, 0x895: 0x07f7, 0x896: 0x0f1f, 0x897: 0x0fe3,
+	0x898: 0x1047, 0x899: 0x1063, 0x89a: 0x1067, 0x89b: 0x107b, 0x89c: 0x14fb, 0x89d: 0x10eb,
+	0x89e: 0x116f, 0x8a0: 0x128f, 0x8a2: 0x1353,
+	0x8a5: 0x1407, 0x8a6: 0x1433,
+	0x8aa: 0x154f, 0x8ab: 0x1553, 0x8ac: 0x1557, 0x8ad: 0x15bb, 0x8ae: 0x142b, 0x8af: 0x14c7,
+	0x8b0: 0x0757, 0x8b1: 0x077b, 0x8b2: 0x078f, 0x8b3: 0x084b, 0x8b4: 0x0857, 0x8b5: 0x0897,
+	0x8b6: 0x094b, 0x8b7: 0x0967, 0x8b8: 0x096f, 0x8b9: 0x09ab, 0x8ba: 0x09b7, 0x8bb: 0x0a93,
+	0x8bc: 0x0a9b, 0x8bd: 0x0ba3, 0x8be: 0x0bcb, 0x8bf: 0x0bd3,
+	// Block 0x23, offset 0x8c0
+	0x8c0: 0x0beb, 0x8c1: 0x0c97, 0x8c2: 0x0cc7, 0x8c3: 0x0ce7, 0x8c4: 0x0d57, 0x8c5: 0x0e1b,
+	0x8c6: 0x0e37, 0x8c7: 0x0e67, 0x8c8: 0x0ebb, 0x8c9: 0x0edb, 0x8ca: 0x0f4f, 0x8cb: 0x102f,
+	0x8cc: 0x104b, 0x8cd: 0x1053, 0x8ce: 0x104f, 0x8cf: 0x1057, 0x8d0: 0x105b, 0x8d1: 0x105f,
+	0x8d2: 0x1073, 0x8d3: 0x1077, 0x8d4: 0x109b, 0x8d5: 0x10af, 0x8d6: 0x10cb, 0x8d7: 0x112f,
+	0x8d8: 0x1137, 0x8d9: 0x113f, 0x8da: 0x1153, 0x8db: 0x117b, 0x8dc: 0x11cb, 0x8dd: 0x11ff,
+	0x8de: 0x11ff, 0x8df: 0x1267, 0x8e0: 0x130f, 0x8e1: 0x1327, 0x8e2: 0x135b, 0x8e3: 0x135f,
+	0x8e4: 0x13a3, 0x8e5: 0x13a7, 0x8e6: 0x13ff, 0x8e7: 0x1407, 0x8e8: 0x14db, 0x8e9: 0x151f,
+	0x8ea: 0x1537, 0x8eb: 0x0b9b, 0x8ec: 0x171e, 0x8ed: 0x11e3,
+	0x8f0: 0x06df, 0x8f1: 0x07e3, 0x8f2: 0x07a3, 0x8f3: 0x074b, 0x8f4: 0x078b, 0x8f5: 0x07b7,
+	0x8f6: 0x0847, 0x8f7: 0x0863, 0x8f8: 0x094b, 0x8f9: 0x0937, 0x8fa: 0x0947, 0x8fb: 0x0963,
+	0x8fc: 0x09af, 0x8fd: 0x09bf, 0x8fe: 0x0a03, 0x8ff: 0x0a0f,
+	// Block 0x24, offset 0x900
+	0x900: 0x0a2b, 0x901: 0x0a3b, 0x902: 0x0b23, 0x903: 0x0b2b, 0x904: 0x0b5b, 0x905: 0x0b7b,
+	0x906: 0x0bab, 0x907: 0x0bc3, 0x908: 0x0bb3, 0x909: 0x0bd3, 0x90a: 0x0bc7, 0x90b: 0x0beb,
+	0x90c: 0x0c07, 0x90d: 0x0c5f, 0x90e: 0x0c6b, 0x90f: 0x0c73, 0x910: 0x0c9b, 0x911: 0x0cdf,
+	0x912: 0x0d0f, 0x913: 0x0d13, 0x914: 0x0d27, 0x915: 0x0da7, 0x916: 0x0db7, 0x917: 0x0e0f,
+	0x918: 0x0e5b, 0x919: 0x0e53, 0x91a: 0x0e67, 0x91b: 0x0e83, 0x91c: 0x0ebb, 0x91d: 0x1013,
+	0x91e: 0x0edf, 0x91f: 0x0f13, 0x920: 0x0f1f, 0x921: 0x0f5f, 0x922: 0x0f7b, 0x923: 0x0f9f,
+	0x924: 0x0fc3, 0x925: 0x0fc7, 0x926: 0x0fe3, 0x927: 0x0fe7, 0x928: 0x0ff7, 0x929: 0x100b,
+	0x92a: 0x1007, 0x92b: 0x1037, 0x92c: 0x10b3, 0x92d: 0x10cb, 0x92e: 0x10e3, 0x92f: 0x111b,
+	0x930: 0x112f, 0x931: 0x114b, 0x932: 0x117b, 0x933: 0x122f, 0x934: 0x1257, 0x935: 0x12cb,
+	0x936: 0x1313, 0x937: 0x131f, 0x938: 0x1327, 0x939: 0x133f, 0x93a: 0x1353, 0x93b: 0x1343,
+	0x93c: 0x135b, 0x93d: 0x1357, 0x93e: 0x134f, 0x93f: 0x135f,
+	// Block 0x25, offset 0x940
+	0x940: 0x136b, 0x941: 0x13a7, 0x942: 0x13e3, 0x943: 0x1413, 0x944: 0x144b, 0x945: 0x146b,
+	0x946: 0x14b7, 0x947: 0x14db, 0x948: 0x14fb, 0x949: 0x150f, 0x94a: 0x151f, 0x94b: 0x152b,
+	0x94c: 0x1537, 0x94d: 0x158b, 0x94e: 0x162b, 0x94f: 0x16b5, 0x950: 0x16b0, 0x951: 0x16e2,
+	0x952: 0x0607, 0x953: 0x062f, 0x954: 0x0633, 0x955: 0x1764, 0x956: 0x1791, 0x957: 0x1809,
+	0x958: 0x1617, 0x959: 0x1627,
+	// Block 0x26, offset 0x980
+	0x980: 0x06fb, 0x981: 0x06f3, 0x982: 0x0703, 0x983: 0x1647, 0x984: 0x0747, 0x985: 0x0757,
+	0x986: 0x075b, 0x987: 0x0763, 0x988: 0x076b, 0x989: 0x076f, 0x98a: 0x077b, 0x98b: 0x0773,
+	0x98c: 0x05b3, 0x98d: 0x165b, 0x98e: 0x078f, 0x98f: 0x0793, 0x990: 0x0797, 0x991: 0x07b3,
+	0x992: 0x164c, 0x993: 0x05b7, 0x994: 0x079f, 0x995: 0x07bf, 0x996: 0x1656, 0x997: 0x07cf,
+	0x998: 0x07d7, 0x999: 0x0737, 0x99a: 0x07df, 0x99b: 0x07e3, 0x99c: 0x1831, 0x99d: 0x07ff,
+	0x99e: 0x0807, 0x99f: 0x05bf, 0x9a0: 0x081f, 0x9a1: 0x0823, 0x9a2: 0x082b, 0x9a3: 0x082f,
+	0x9a4: 0x05c3, 0x9a5: 0x0847, 0x9a6: 0x084b, 0x9a7: 0x0857, 0x9a8: 0x0863, 0x9a9: 0x0867,
+	0x9aa: 0x086b, 0x9ab: 0x0873, 0x9ac: 0x0893, 0x9ad: 0x0897, 0x9ae: 0x089f, 0x9af: 0x08af,
+	0x9b0: 0x08b7, 0x9b1: 0x08bb, 0x9b2: 0x08bb, 0x9b3: 0x08bb, 0x9b4: 0x166a, 0x9b5: 0x0e93,
+	0x9b6: 0x08cf, 0x9b7: 0x08d7, 0x9b8: 0x166f, 0x9b9: 0x08e3, 0x9ba: 0x08eb, 0x9bb: 0x08f3,
+	0x9bc: 0x091b, 0x9bd: 0x0907, 0x9be: 0x0913, 0x9bf: 0x0917,
+	// Block 0x27, offset 0x9c0
+	0x9c0: 0x091f, 0x9c1: 0x0927, 0x9c2: 0x092b, 0x9c3: 0x0933, 0x9c4: 0x093b, 0x9c5: 0x093f,
+	0x9c6: 0x093f, 0x9c7: 0x0947, 0x9c8: 0x094f, 0x9c9: 0x0953, 0x9ca: 0x095f, 0x9cb: 0x0983,
+	0x9cc: 0x0967, 0x9cd: 0x0987, 0x9ce: 0x096b, 0x9cf: 0x0973, 0x9d0: 0x080b, 0x9d1: 0x09cf,
+	0x9d2: 0x0997, 0x9d3: 0x099b, 0x9d4: 0x099f, 0x9d5: 0x0993, 0x9d6: 0x09a7, 0x9d7: 0x09a3,
+	0x9d8: 0x09bb, 0x9d9: 0x1674, 0x9da: 0x09d7, 0x9db: 0x09db, 0x9dc: 0x09e3, 0x9dd: 0x09ef,
+	0x9de: 0x09f7, 0x9df: 0x0a13, 0x9e0: 0x1679, 0x9e1: 0x167e, 0x9e2: 0x0a1f, 0x9e3: 0x0a23,
+	0x9e4: 0x0a27, 0x9e5: 0x0a1b, 0x9e6: 0x0a2f, 0x9e7: 0x05c7, 0x9e8: 0x05cb, 0x9e9: 0x0a37,
+	0x9ea: 0x0a3f, 0x9eb: 0x0a3f, 0x9ec: 0x1683, 0x9ed: 0x0a5b, 0x9ee: 0x0a5f, 0x9ef: 0x0a63,
+	0x9f0: 0x0a6b, 0x9f1: 0x1688, 0x9f2: 0x0a73, 0x9f3: 0x0a77, 0x9f4: 0x0b4f, 0x9f5: 0x0a7f,
+	0x9f6: 0x05cf, 0x9f7: 0x0a8b, 0x9f8: 0x0a9b, 0x9f9: 0x0aa7, 0x9fa: 0x0aa3, 0x9fb: 0x1692,
+	0x9fc: 0x0aaf, 0x9fd: 0x1697, 0x9fe: 0x0abb, 0x9ff: 0x0ab7,
+	// Block 0x28, offset 0xa00
+	0xa00: 0x0abf, 0xa01: 0x0acf, 0xa02: 0x0ad3, 0xa03: 0x05d3, 0xa04: 0x0ae3, 0xa05: 0x0aeb,
+	0xa06: 0x0aef, 0xa07: 0x0af3, 0xa08: 0x05d7, 0xa09: 0x169c, 0xa0a: 0x05db, 0xa0b: 0x0b0f,
+	0xa0c: 0x0b13, 0xa0d: 0x0b17, 0xa0e: 0x0b1f, 0xa0f: 0x1863, 0xa10: 0x0b37, 0xa11: 0x16a6,
+	0xa12: 0x16a6, 0xa13: 0x11d7, 0xa14: 0x0b47, 0xa15: 0x0b47, 0xa16: 0x05df, 0xa17: 0x16c9,
+	0xa18: 0x179b, 0xa19: 0x0b57, 0xa1a: 0x0b5f, 0xa1b: 0x05e3, 0xa1c: 0x0b73, 0xa1d: 0x0b83,
+	0xa1e: 0x0b87, 0xa1f: 0x0b8f, 0xa20: 0x0b9f, 0xa21: 0x05eb, 0xa22: 0x05e7, 0xa23: 0x0ba3,
+	0xa24: 0x16ab, 0xa25: 0x0ba7, 0xa26: 0x0bbb, 0xa27: 0x0bbf, 0xa28: 0x0bc3, 0xa29: 0x0bbf,
+	0xa2a: 0x0bcf, 0xa2b: 0x0bd3, 0xa2c: 0x0be3, 0xa2d: 0x0bdb, 0xa2e: 0x0bdf, 0xa2f: 0x0be7,
+	0xa30: 0x0beb, 0xa31: 0x0bef, 0xa32: 0x0bfb, 0xa33: 0x0bff, 0xa34: 0x0c17, 0xa35: 0x0c1f,
+	0xa36: 0x0c2f, 0xa37: 0x0c43, 0xa38: 0x16ba, 0xa39: 0x0c3f, 0xa3a: 0x0c33, 0xa3b: 0x0c4b,
+	0xa3c: 0x0c53, 0xa3d: 0x0c67, 0xa3e: 0x16bf, 0xa3f: 0x0c6f,
+	// Block 0x29, offset 0xa40
+	0xa40: 0x0c63, 0xa41: 0x0c5b, 0xa42: 0x05ef, 0xa43: 0x0c77, 0xa44: 0x0c7f, 0xa45: 0x0c87,
+	0xa46: 0x0c7b, 0xa47: 0x05f3, 0xa48: 0x0c97, 0xa49: 0x0c9f, 0xa4a: 0x16c4, 0xa4b: 0x0ccb,
+	0xa4c: 0x0cff, 0xa4d: 0x0cdb, 0xa4e: 0x05ff, 0xa4f: 0x0ce7, 0xa50: 0x05fb, 0xa51: 0x05f7,
+	0xa52: 0x07c3, 0xa53: 0x07c7, 0xa54: 0x0d03, 0xa55: 0x0ceb, 0xa56: 0x11ab, 0xa57: 0x0663,
+	0xa58: 0x0d0f, 0xa59: 0x0d13, 0xa5a: 0x0d17, 0xa5b: 0x0d2b, 0xa5c: 0x0d23, 0xa5d: 0x16dd,
+	0xa5e: 0x0603, 0xa5f: 0x0d3f, 0xa60: 0x0d33, 0xa61: 0x0d4f, 0xa62: 0x0d57, 0xa63: 0x16e7,
+	0xa64: 0x0d5b, 0xa65: 0x0d47, 0xa66: 0x0d63, 0xa67: 0x0607, 0xa68: 0x0d67, 0xa69: 0x0d6b,
+	0xa6a: 0x0d6f, 0xa6b: 0x0d7b, 0xa6c: 0x16ec, 0xa6d: 0x0d83, 0xa6e: 0x060b, 0xa6f: 0x0d8f,
+	0xa70: 0x16f1, 0xa71: 0x0d93, 0xa72: 0x060f, 0xa73: 0x0d9f, 0xa74: 0x0dab, 0xa75: 0x0db7,
+	0xa76: 0x0dbb, 0xa77: 0x16f6, 0xa78: 0x168d, 0xa79: 0x16fb, 0xa7a: 0x0ddb, 0xa7b: 0x1700,
+	0xa7c: 0x0de7, 0xa7d: 0x0def, 0xa7e: 0x0ddf, 0xa7f: 0x0dfb,
+	// Block 0x2a, offset 0xa80
+	0xa80: 0x0e0b, 0xa81: 0x0e1b, 0xa82: 0x0e0f, 0xa83: 0x0e13, 0xa84: 0x0e1f, 0xa85: 0x0e23,
+	0xa86: 0x1705, 0xa87: 0x0e07, 0xa88: 0x0e3b, 0xa89: 0x0e3f, 0xa8a: 0x0613, 0xa8b: 0x0e53,
+	0xa8c: 0x0e4f, 0xa8d: 0x170a, 0xa8e: 0x0e33, 0xa8f: 0x0e6f, 0xa90: 0x170f, 0xa91: 0x1714,
+	0xa92: 0x0e73, 0xa93: 0x0e87, 0xa94: 0x0e83, 0xa95: 0x0e7f, 0xa96: 0x0617, 0xa97: 0x0e8b,
+	0xa98: 0x0e9b, 0xa99: 0x0e97, 0xa9a: 0x0ea3, 0xa9b: 0x1651, 0xa9c: 0x0eb3, 0xa9d: 0x1719,
+	0xa9e: 0x0ebf, 0xa9f: 0x1723, 0xaa0: 0x0ed3, 0xaa1: 0x0edf, 0xaa2: 0x0ef3, 0xaa3: 0x1728,
+	0xaa4: 0x0f07, 0xaa5: 0x0f0b, 0xaa6: 0x172d, 0xaa7: 0x1732, 0xaa8: 0x0f27, 0xaa9: 0x0f37,
+	0xaaa: 0x061b, 0xaab: 0x0f3b, 0xaac: 0x061f, 0xaad: 0x061f, 0xaae: 0x0f53, 0xaaf: 0x0f57,
+	0xab0: 0x0f5f, 0xab1: 0x0f63, 0xab2: 0x0f6f, 0xab3: 0x0623, 0xab4: 0x0f87, 0xab5: 0x1737,
+	0xab6: 0x0fa3, 0xab7: 0x173c, 0xab8: 0x0faf, 0xab9: 0x16a1, 0xaba: 0x0fbf, 0xabb: 0x1741,
+	0xabc: 0x1746, 0xabd: 0x174b, 0xabe: 0x0627, 0xabf: 0x062b,
+	// Block 0x2b, offset 0xac0
+	0xac0: 0x0ff7, 0xac1: 0x1755, 0xac2: 0x1750, 0xac3: 0x175a, 0xac4: 0x175f, 0xac5: 0x0fff,
+	0xac6: 0x1003, 0xac7: 0x1003, 0xac8: 0x100b, 0xac9: 0x0633, 0xaca: 0x100f, 0xacb: 0x0637,
+	0xacc: 0x063b, 0xacd: 0x1769, 0xace: 0x1023, 0xacf: 0x102b, 0xad0: 0x1037, 0xad1: 0x063f,
+	0xad2: 0x176e, 0xad3: 0x105b, 0xad4: 0x1773, 0xad5: 0x1778, 0xad6: 0x107b, 0xad7: 0x1093,
+	0xad8: 0x0643, 0xad9: 0x109b, 0xada: 0x109f, 0xadb: 0x10a3, 0xadc: 0x177d, 0xadd: 0x1782,
+	0xade: 0x1782, 0xadf: 0x10bb, 0xae0: 0x0647, 0xae1: 0x1787, 0xae2: 0x10cf, 0xae3: 0x10d3,
+	0xae4: 0x064b, 0xae5: 0x178c, 0xae6: 0x10ef, 0xae7: 0x064f, 0xae8: 0x10ff, 0xae9: 0x10f7,
+	0xaea: 0x1107, 0xaeb: 0x1796, 0xaec: 0x111f, 0xaed: 0x0653, 0xaee: 0x112b, 0xaef: 0x1133,
+	0xaf0: 0x1143, 0xaf1: 0x0657, 0xaf2: 0x17a0, 0xaf3: 0x17a5, 0xaf4: 0x065b, 0xaf5: 0x17aa,
+	0xaf6: 0x115b, 0xaf7: 0x17af, 0xaf8: 0x1167, 0xaf9: 0x1173, 0xafa: 0x117b, 0xafb: 0x17b4,
+	0xafc: 0x17b9, 0xafd: 0x118f, 0xafe: 0x17be, 0xaff: 0x1197,
+	// Block 0x2c, offset 0xb00
+	0xb00: 0x16ce, 0xb01: 0x065f, 0xb02: 0x11af, 0xb03: 0x11b3, 0xb04: 0x0667, 0xb05: 0x11b7,
+	0xb06: 0x0a33, 0xb07: 0x17c3, 0xb08: 0x17c8, 0xb09: 0x16d3, 0xb0a: 0x16d8, 0xb0b: 0x11d7,
+	0xb0c: 0x11db, 0xb0d: 0x13f3, 0xb0e: 0x066b, 0xb0f: 0x1207, 0xb10: 0x1203, 0xb11: 0x120b,
+	0xb12: 0x083f, 0xb13: 0x120f, 0xb14: 0x1213, 0xb15: 0x1217, 0xb16: 0x121f, 0xb17: 0x17cd,
+	0xb18: 0x121b, 0xb19: 0x1223, 0xb1a: 0x1237, 0xb1b: 0x123b, 0xb1c: 0x1227, 0xb1d: 0x123f,
+	0xb1e: 0x1253, 0xb1f: 0x1267, 0xb20: 0x1233, 0xb21: 0x1247, 0xb22: 0x124b, 0xb23: 0x124f,
+	0xb24: 0x17d2, 0xb25: 0x17dc, 0xb26: 0x17d7, 0xb27: 0x066f, 0xb28: 0x126f, 0xb29: 0x1273,
+	0xb2a: 0x127b, 0xb2b: 0x17f0, 0xb2c: 0x127f, 0xb2d: 0x17e1, 0xb2e: 0x0673, 0xb2f: 0x0677,
+	0xb30: 0x17e6, 0xb31: 0x17eb, 0xb32: 0x067b, 0xb33: 0x129f, 0xb34: 0x12a3, 0xb35: 0x12a7,
+	0xb36: 0x12ab, 0xb37: 0x12b7, 0xb38: 0x12b3, 0xb39: 0x12bf, 0xb3a: 0x12bb, 0xb3b: 0x12cb,
+	0xb3c: 0x12c3, 0xb3d: 0x12c7, 0xb3e: 0x12cf, 0xb3f: 0x067f,
+	// Block 0x2d, offset 0xb40
+	0xb40: 0x12d7, 0xb41: 0x12db, 0xb42: 0x0683, 0xb43: 0x12eb, 0xb44: 0x12ef, 0xb45: 0x17f5,
+	0xb46: 0x12fb, 0xb47: 0x12ff, 0xb48: 0x0687, 0xb49: 0x130b, 0xb4a: 0x05bb, 0xb4b: 0x17fa,
+	0xb4c: 0x17ff, 0xb4d: 0x068b, 0xb4e: 0x068f, 0xb4f: 0x1337, 0xb50: 0x134f, 0xb51: 0x136b,
+	0xb52: 0x137b, 0xb53: 0x1804, 0xb54: 0x138f, 0xb55: 0x1393, 0xb56: 0x13ab, 0xb57: 0x13b7,
+	0xb58: 0x180e, 0xb59: 0x1660, 0xb5a: 0x13c3, 0xb5b: 0x13bf, 0xb5c: 0x13cb, 0xb5d: 0x1665,
+	0xb5e: 0x13d7, 0xb5f: 0x13e3, 0xb60: 0x1813, 0xb61: 0x1818, 0xb62: 0x1423, 0xb63: 0x142f,
+	0xb64: 0x1437, 0xb65: 0x181d, 0xb66: 0x143b, 0xb67: 0x1467, 0xb68: 0x1473, 0xb69: 0x1477,
+	0xb6a: 0x146f, 0xb6b: 0x1483, 0xb6c: 0x1487, 0xb6d: 0x1822, 0xb6e: 0x1493, 0xb6f: 0x0693,
+	0xb70: 0x149b, 0xb71: 0x1827, 0xb72: 0x0697, 0xb73: 0x14d3, 0xb74: 0x0ac3, 0xb75: 0x14eb,
+	0xb76: 0x182c, 0xb77: 0x1836, 0xb78: 0x069b, 0xb79: 0x069f, 0xb7a: 0x1513, 0xb7b: 0x183b,
+	0xb7c: 0x06a3, 0xb7d: 0x1840, 0xb7e: 0x152b, 0xb7f: 0x152b,
+	// Block 0x2e, offset 0xb80
+	0xb80: 0x1533, 0xb81: 0x1845, 0xb82: 0x154b, 0xb83: 0x06a7, 0xb84: 0x155b, 0xb85: 0x1567,
+	0xb86: 0x156f, 0xb87: 0x1577, 0xb88: 0x06ab, 0xb89: 0x184a, 0xb8a: 0x158b, 0xb8b: 0x15a7,
+	0xb8c: 0x15b3, 0xb8d: 0x06af, 0xb8e: 0x06b3, 0xb8f: 0x15b7, 0xb90: 0x184f, 0xb91: 0x06b7,
+	0xb92: 0x1854, 0xb93: 0x1859, 0xb94: 0x185e, 0xb95: 0x15db, 0xb96: 0x06bb, 0xb97: 0x15ef,
+	0xb98: 0x15f7, 0xb99: 0x15fb, 0xb9a: 0x1603, 0xb9b: 0x160b, 0xb9c: 0x1613, 0xb9d: 0x1868,
+}
+
+// nfcIndex: 22 blocks, 1408 entries, 1408 bytes
+// Block 0 is the zero block.
+var nfcIndex = [1408]uint8{
+	// Block 0x0, offset 0x0
+	// Block 0x1, offset 0x40
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc2: 0x2d, 0xc3: 0x01, 0xc4: 0x02, 0xc5: 0x03, 0xc6: 0x2e, 0xc7: 0x04,
+	0xc8: 0x05, 0xca: 0x2f, 0xcb: 0x30, 0xcc: 0x06, 0xcd: 0x07, 0xce: 0x08, 0xcf: 0x31,
+	0xd0: 0x09, 0xd1: 0x32, 0xd2: 0x33, 0xd3: 0x0a, 0xd6: 0x0b, 0xd7: 0x34,
+	0xd8: 0x35, 0xd9: 0x0c, 0xdb: 0x36, 0xdc: 0x37, 0xdd: 0x38, 0xdf: 0x39,
+	0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05,
+	0xea: 0x06, 0xeb: 0x07, 0xec: 0x08, 0xed: 0x09, 0xef: 0x0a,
+	0xf0: 0x13,
+	// Block 0x4, offset 0x100
+	0x120: 0x3a, 0x121: 0x3b, 0x123: 0x3c, 0x124: 0x3d, 0x125: 0x3e, 0x126: 0x3f, 0x127: 0x40,
+	0x128: 0x41, 0x129: 0x42, 0x12a: 0x43, 0x12b: 0x44, 0x12c: 0x3f, 0x12d: 0x45, 0x12e: 0x46, 0x12f: 0x47,
+	0x131: 0x48, 0x132: 0x49, 0x133: 0x4a, 0x134: 0x4b, 0x135: 0x4c, 0x137: 0x4d,
+	0x138: 0x4e, 0x139: 0x4f, 0x13a: 0x50, 0x13b: 0x51, 0x13c: 0x52, 0x13d: 0x53, 0x13e: 0x54, 0x13f: 0x55,
+	// Block 0x5, offset 0x140
+	0x140: 0x56, 0x142: 0x57, 0x144: 0x58, 0x145: 0x59, 0x146: 0x5a, 0x147: 0x5b,
+	0x14d: 0x5c,
+	0x15c: 0x5d, 0x15f: 0x5e,
+	0x162: 0x5f, 0x164: 0x60,
+	0x168: 0x61, 0x169: 0x62, 0x16a: 0x63, 0x16c: 0x0d, 0x16d: 0x64, 0x16e: 0x65, 0x16f: 0x66,
+	0x170: 0x67, 0x173: 0x68, 0x177: 0x0e,
+	0x178: 0x0f, 0x179: 0x10, 0x17a: 0x11, 0x17b: 0x12, 0x17c: 0x13, 0x17d: 0x14, 0x17e: 0x15, 0x17f: 0x16,
+	// Block 0x6, offset 0x180
+	0x180: 0x69, 0x183: 0x6a, 0x184: 0x6b, 0x186: 0x6c, 0x187: 0x6d,
+	0x188: 0x6e, 0x189: 0x17, 0x18a: 0x18, 0x18b: 0x6f, 0x18c: 0x70,
+	0x1ab: 0x71,
+	0x1b3: 0x72, 0x1b5: 0x73, 0x1b7: 0x74,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x75, 0x1c1: 0x19, 0x1c2: 0x1a, 0x1c3: 0x1b, 0x1c4: 0x76, 0x1c5: 0x77,
+	0x1c9: 0x78, 0x1cc: 0x79, 0x1cd: 0x7a,
+	// Block 0x8, offset 0x200
+	0x219: 0x7b, 0x21a: 0x7c, 0x21b: 0x7d,
+	0x220: 0x7e, 0x223: 0x7f, 0x224: 0x80, 0x225: 0x81, 0x226: 0x82, 0x227: 0x83,
+	0x22a: 0x84, 0x22b: 0x85, 0x22f: 0x86,
+	0x230: 0x87, 0x231: 0x88, 0x232: 0x89, 0x233: 0x8a, 0x234: 0x8b, 0x235: 0x8c, 0x236: 0x8d, 0x237: 0x87,
+	0x238: 0x88, 0x239: 0x89, 0x23a: 0x8a, 0x23b: 0x8b, 0x23c: 0x8c, 0x23d: 0x8d, 0x23e: 0x87, 0x23f: 0x88,
+	// Block 0x9, offset 0x240
+	0x240: 0x89, 0x241: 0x8a, 0x242: 0x8b, 0x243: 0x8c, 0x244: 0x8d, 0x245: 0x87, 0x246: 0x88, 0x247: 0x89,
+	0x248: 0x8a, 0x249: 0x8b, 0x24a: 0x8c, 0x24b: 0x8d, 0x24c: 0x87, 0x24d: 0x88, 0x24e: 0x89, 0x24f: 0x8a,
+	0x250: 0x8b, 0x251: 0x8c, 0x252: 0x8d, 0x253: 0x87, 0x254: 0x88, 0x255: 0x89, 0x256: 0x8a, 0x257: 0x8b,
+	0x258: 0x8c, 0x259: 0x8d, 0x25a: 0x87, 0x25b: 0x88, 0x25c: 0x89, 0x25d: 0x8a, 0x25e: 0x8b, 0x25f: 0x8c,
+	0x260: 0x8d, 0x261: 0x87, 0x262: 0x88, 0x263: 0x89, 0x264: 0x8a, 0x265: 0x8b, 0x266: 0x8c, 0x267: 0x8d,
+	0x268: 0x87, 0x269: 0x88, 0x26a: 0x89, 0x26b: 0x8a, 0x26c: 0x8b, 0x26d: 0x8c, 0x26e: 0x8d, 0x26f: 0x87,
+	0x270: 0x88, 0x271: 0x89, 0x272: 0x8a, 0x273: 0x8b, 0x274: 0x8c, 0x275: 0x8d, 0x276: 0x87, 0x277: 0x88,
+	0x278: 0x89, 0x279: 0x8a, 0x27a: 0x8b, 0x27b: 0x8c, 0x27c: 0x8d, 0x27d: 0x87, 0x27e: 0x88, 0x27f: 0x89,
+	// Block 0xa, offset 0x280
+	0x280: 0x8a, 0x281: 0x8b, 0x282: 0x8c, 0x283: 0x8d, 0x284: 0x87, 0x285: 0x88, 0x286: 0x89, 0x287: 0x8a,
+	0x288: 0x8b, 0x289: 0x8c, 0x28a: 0x8d, 0x28b: 0x87, 0x28c: 0x88, 0x28d: 0x89, 0x28e: 0x8a, 0x28f: 0x8b,
+	0x290: 0x8c, 0x291: 0x8d, 0x292: 0x87, 0x293: 0x88, 0x294: 0x89, 0x295: 0x8a, 0x296: 0x8b, 0x297: 0x8c,
+	0x298: 0x8d, 0x299: 0x87, 0x29a: 0x88, 0x29b: 0x89, 0x29c: 0x8a, 0x29d: 0x8b, 0x29e: 0x8c, 0x29f: 0x8d,
+	0x2a0: 0x87, 0x2a1: 0x88, 0x2a2: 0x89, 0x2a3: 0x8a, 0x2a4: 0x8b, 0x2a5: 0x8c, 0x2a6: 0x8d, 0x2a7: 0x87,
+	0x2a8: 0x88, 0x2a9: 0x89, 0x2aa: 0x8a, 0x2ab: 0x8b, 0x2ac: 0x8c, 0x2ad: 0x8d, 0x2ae: 0x87, 0x2af: 0x88,
+	0x2b0: 0x89, 0x2b1: 0x8a, 0x2b2: 0x8b, 0x2b3: 0x8c, 0x2b4: 0x8d, 0x2b5: 0x87, 0x2b6: 0x88, 0x2b7: 0x89,
+	0x2b8: 0x8a, 0x2b9: 0x8b, 0x2ba: 0x8c, 0x2bb: 0x8d, 0x2bc: 0x87, 0x2bd: 0x88, 0x2be: 0x89, 0x2bf: 0x8a,
+	// Block 0xb, offset 0x2c0
+	0x2c0: 0x8b, 0x2c1: 0x8c, 0x2c2: 0x8d, 0x2c3: 0x87, 0x2c4: 0x88, 0x2c5: 0x89, 0x2c6: 0x8a, 0x2c7: 0x8b,
+	0x2c8: 0x8c, 0x2c9: 0x8d, 0x2ca: 0x87, 0x2cb: 0x88, 0x2cc: 0x89, 0x2cd: 0x8a, 0x2ce: 0x8b, 0x2cf: 0x8c,
+	0x2d0: 0x8d, 0x2d1: 0x87, 0x2d2: 0x88, 0x2d3: 0x89, 0x2d4: 0x8a, 0x2d5: 0x8b, 0x2d6: 0x8c, 0x2d7: 0x8d,
+	0x2d8: 0x87, 0x2d9: 0x88, 0x2da: 0x89, 0x2db: 0x8a, 0x2dc: 0x8b, 0x2dd: 0x8c, 0x2de: 0x8e,
+	// Block 0xc, offset 0x300
+	0x324: 0x1c, 0x325: 0x1d, 0x326: 0x1e, 0x327: 0x1f,
+	0x328: 0x20, 0x329: 0x21, 0x32a: 0x22, 0x32b: 0x23, 0x32c: 0x8f, 0x32d: 0x90, 0x32e: 0x91,
+	0x331: 0x92, 0x332: 0x93, 0x333: 0x94, 0x334: 0x95,
+	0x338: 0x96, 0x339: 0x97, 0x33a: 0x98, 0x33b: 0x99, 0x33e: 0x9a, 0x33f: 0x9b,
+	// Block 0xd, offset 0x340
+	0x347: 0x9c,
+	0x34b: 0x9d, 0x34d: 0x9e,
+	0x368: 0x9f, 0x36b: 0xa0,
+	// Block 0xe, offset 0x380
+	0x381: 0xa1, 0x382: 0xa2, 0x384: 0xa3, 0x385: 0x82, 0x387: 0xa4,
+	0x388: 0xa5, 0x38b: 0xa6, 0x38c: 0x3f, 0x38d: 0xa7,
+	0x391: 0xa8, 0x392: 0xa9, 0x393: 0xaa, 0x396: 0xab, 0x397: 0xac,
+	0x398: 0x73, 0x39a: 0xad, 0x39c: 0xae,
+	0x3a8: 0xaf, 0x3a9: 0xb0, 0x3aa: 0xb1,
+	0x3b0: 0x73, 0x3b5: 0xb2,
+	// Block 0xf, offset 0x3c0
+	0x3eb: 0xb3, 0x3ec: 0xb4,
+	// Block 0x10, offset 0x400
+	0x432: 0xb5,
+	// Block 0x11, offset 0x440
+	0x445: 0xb6, 0x446: 0xb7, 0x447: 0xb8,
+	0x449: 0xb9,
+	// Block 0x12, offset 0x480
+	0x480: 0xba,
+	0x4a3: 0xbb, 0x4a5: 0xbc,
+	// Block 0x13, offset 0x4c0
+	0x4c8: 0xbd,
+	// Block 0x14, offset 0x500
+	0x520: 0x24, 0x521: 0x25, 0x522: 0x26, 0x523: 0x27, 0x524: 0x28, 0x525: 0x29, 0x526: 0x2a, 0x527: 0x2b,
+	0x528: 0x2c,
+	// Block 0x15, offset 0x540
+	0x550: 0x0b, 0x551: 0x0c, 0x556: 0x0d,
+	0x55b: 0x0e, 0x55d: 0x0f, 0x55e: 0x10, 0x55f: 0x11,
+	0x56f: 0x12,
+}
+
+// nfcSparseOffset: 145 entries, 290 bytes
+var nfcSparseOffset = []uint16{0x0, 0x5, 0x9, 0xb, 0xd, 0x18, 0x28, 0x2a, 0x2f, 0x3a, 0x49, 0x56, 0x5e, 0x62, 0x67, 0x69, 0x7a, 0x82, 0x89, 0x8c, 0x93, 0x97, 0x9b, 0x9d, 0x9f, 0xa8, 0xac, 0xb3, 0xb8, 0xbb, 0xc5, 0xc8, 0xcf, 0xd7, 0xda, 0xdc, 0xde, 0xe0, 0xe5, 0xf6, 0x102, 0x104, 0x10a, 0x10c, 0x10e, 0x110, 0x112, 0x114, 0x116, 0x119, 0x11c, 0x11e, 0x121, 0x124, 0x128, 0x12d, 0x136, 0x138, 0x13b, 0x13d, 0x148, 0x14c, 0x15a, 0x15d, 0x163, 0x169, 0x174, 0x178, 0x17a, 0x17c, 0x17e, 0x180, 0x182, 0x188, 0x18c, 0x18e, 0x190, 0x198, 0x19c, 0x19f, 0x1a1, 0x1a3, 0x1a5, 0x1a8, 0x1aa, 0x1ac, 0x1ae, 0x1b0, 0x1b6, 0x1b9, 0x1bb, 0x1c2, 0x1c8, 0x1ce, 0x1d6, 0x1dc, 0x1e2, 0x1e8, 0x1ec, 0x1fa, 0x203, 0x206, 0x209, 0x20b, 0x20e, 0x210, 0x214, 0x219, 0x21b, 0x21d, 0x222, 0x228, 0x22a, 0x22c, 0x22e, 0x234, 0x237, 0x23a, 0x242, 0x249, 0x24c, 0x24f, 0x251, 0x259, 0x25c, 0x263, 0x266, 0x26c, 0x26e, 0x271, 0x273, 0x275, 0x277, 0x279, 0x27c, 0x27e, 0x280, 0x282, 0x28f, 0x299, 0x29b, 0x29d, 0x2a3, 0x2a5, 0x2a8}
+
+// nfcSparseValues: 682 entries, 2728 bytes
+var nfcSparseValues = [682]valueRange{
+	// Block 0x0, offset 0x0
+	{value: 0x0000, lo: 0x04},
+	{value: 0xa100, lo: 0xa8, hi: 0xa8},
+	{value: 0x8100, lo: 0xaf, hi: 0xaf},
+	{value: 0x8100, lo: 0xb4, hi: 0xb4},
+	{value: 0x8100, lo: 0xb8, hi: 0xb8},
+	// Block 0x1, offset 0x5
+	{value: 0x0091, lo: 0x03},
+	{value: 0x46e2, lo: 0xa0, hi: 0xa1},
+	{value: 0x4714, lo: 0xaf, hi: 0xb0},
+	{value: 0xa000, lo: 0xb7, hi: 0xb7},
+	// Block 0x2, offset 0x9
+	{value: 0x0000, lo: 0x01},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	// Block 0x3, offset 0xb
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0x98, hi: 0x9d},
+	// Block 0x4, offset 0xd
+	{value: 0x0006, lo: 0x0a},
+	{value: 0xa000, lo: 0x81, hi: 0x81},
+	{value: 0xa000, lo: 0x85, hi: 0x85},
+	{value: 0xa000, lo: 0x89, hi: 0x89},
+	{value: 0x4840, lo: 0x8a, hi: 0x8a},
+	{value: 0x485e, lo: 0x8b, hi: 0x8b},
+	{value: 0x36c7, lo: 0x8c, hi: 0x8c},
+	{value: 0x36df, lo: 0x8d, hi: 0x8d},
+	{value: 0x4876, lo: 0x8e, hi: 0x8e},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x36fd, lo: 0x93, hi: 0x94},
+	// Block 0x5, offset 0x18
+	{value: 0x0000, lo: 0x0f},
+	{value: 0xa000, lo: 0x83, hi: 0x83},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0xa000, lo: 0x8b, hi: 0x8b},
+	{value: 0xa000, lo: 0x8d, hi: 0x8d},
+	{value: 0x37a5, lo: 0x90, hi: 0x90},
+	{value: 0x37b1, lo: 0x91, hi: 0x91},
+	{value: 0x379f, lo: 0x93, hi: 0x93},
+	{value: 0xa000, lo: 0x96, hi: 0x96},
+	{value: 0x3817, lo: 0x97, hi: 0x97},
+	{value: 0x37e1, lo: 0x9c, hi: 0x9c},
+	{value: 0x37c9, lo: 0x9d, hi: 0x9d},
+	{value: 0x37f3, lo: 0x9e, hi: 0x9e},
+	{value: 0xa000, lo: 0xb4, hi: 0xb5},
+	{value: 0x381d, lo: 0xb6, hi: 0xb6},
+	{value: 0x3823, lo: 0xb7, hi: 0xb7},
+	// Block 0x6, offset 0x28
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x83, hi: 0x87},
+	// Block 0x7, offset 0x2a
+	{value: 0x0001, lo: 0x04},
+	{value: 0x8113, lo: 0x81, hi: 0x82},
+	{value: 0x8132, lo: 0x84, hi: 0x84},
+	{value: 0x812d, lo: 0x85, hi: 0x85},
+	{value: 0x810d, lo: 0x87, hi: 0x87},
+	// Block 0x8, offset 0x2f
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x8132, lo: 0x90, hi: 0x97},
+	{value: 0x8119, lo: 0x98, hi: 0x98},
+	{value: 0x811a, lo: 0x99, hi: 0x99},
+	{value: 0x811b, lo: 0x9a, hi: 0x9a},
+	{value: 0x3841, lo: 0xa2, hi: 0xa2},
+	{value: 0x3847, lo: 0xa3, hi: 0xa3},
+	{value: 0x3853, lo: 0xa4, hi: 0xa4},
+	{value: 0x384d, lo: 0xa5, hi: 0xa5},
+	{value: 0x3859, lo: 0xa6, hi: 0xa6},
+	{value: 0xa000, lo: 0xa7, hi: 0xa7},
+	// Block 0x9, offset 0x3a
+	{value: 0x0000, lo: 0x0e},
+	{value: 0x386b, lo: 0x80, hi: 0x80},
+	{value: 0xa000, lo: 0x81, hi: 0x81},
+	{value: 0x385f, lo: 0x82, hi: 0x82},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x3865, lo: 0x93, hi: 0x93},
+	{value: 0xa000, lo: 0x95, hi: 0x95},
+	{value: 0x8132, lo: 0x96, hi: 0x9c},
+	{value: 0x8132, lo: 0x9f, hi: 0xa2},
+	{value: 0x812d, lo: 0xa3, hi: 0xa3},
+	{value: 0x8132, lo: 0xa4, hi: 0xa4},
+	{value: 0x8132, lo: 0xa7, hi: 0xa8},
+	{value: 0x812d, lo: 0xaa, hi: 0xaa},
+	{value: 0x8132, lo: 0xab, hi: 0xac},
+	{value: 0x812d, lo: 0xad, hi: 0xad},
+	// Block 0xa, offset 0x49
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x811f, lo: 0x91, hi: 0x91},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	{value: 0x812d, lo: 0xb1, hi: 0xb1},
+	{value: 0x8132, lo: 0xb2, hi: 0xb3},
+	{value: 0x812d, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb5, hi: 0xb6},
+	{value: 0x812d, lo: 0xb7, hi: 0xb9},
+	{value: 0x8132, lo: 0xba, hi: 0xba},
+	{value: 0x812d, lo: 0xbb, hi: 0xbc},
+	{value: 0x8132, lo: 0xbd, hi: 0xbd},
+	{value: 0x812d, lo: 0xbe, hi: 0xbe},
+	{value: 0x8132, lo: 0xbf, hi: 0xbf},
+	// Block 0xb, offset 0x56
+	{value: 0x0005, lo: 0x07},
+	{value: 0x8132, lo: 0x80, hi: 0x80},
+	{value: 0x8132, lo: 0x81, hi: 0x81},
+	{value: 0x812d, lo: 0x82, hi: 0x83},
+	{value: 0x812d, lo: 0x84, hi: 0x85},
+	{value: 0x812d, lo: 0x86, hi: 0x87},
+	{value: 0x812d, lo: 0x88, hi: 0x89},
+	{value: 0x8132, lo: 0x8a, hi: 0x8a},
+	// Block 0xc, offset 0x5e
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8132, lo: 0xab, hi: 0xb1},
+	{value: 0x812d, lo: 0xb2, hi: 0xb2},
+	{value: 0x8132, lo: 0xb3, hi: 0xb3},
+	// Block 0xd, offset 0x62
+	{value: 0x0000, lo: 0x04},
+	{value: 0x8132, lo: 0x96, hi: 0x99},
+	{value: 0x8132, lo: 0x9b, hi: 0xa3},
+	{value: 0x8132, lo: 0xa5, hi: 0xa7},
+	{value: 0x8132, lo: 0xa9, hi: 0xad},
+	// Block 0xe, offset 0x67
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x99, hi: 0x9b},
+	// Block 0xf, offset 0x69
+	{value: 0x0000, lo: 0x10},
+	{value: 0x8132, lo: 0x94, hi: 0xa1},
+	{value: 0x812d, lo: 0xa3, hi: 0xa3},
+	{value: 0x8132, lo: 0xa4, hi: 0xa5},
+	{value: 0x812d, lo: 0xa6, hi: 0xa6},
+	{value: 0x8132, lo: 0xa7, hi: 0xa8},
+	{value: 0x812d, lo: 0xa9, hi: 0xa9},
+	{value: 0x8132, lo: 0xaa, hi: 0xac},
+	{value: 0x812d, lo: 0xad, hi: 0xaf},
+	{value: 0x8116, lo: 0xb0, hi: 0xb0},
+	{value: 0x8117, lo: 0xb1, hi: 0xb1},
+	{value: 0x8118, lo: 0xb2, hi: 0xb2},
+	{value: 0x8132, lo: 0xb3, hi: 0xb5},
+	{value: 0x812d, lo: 0xb6, hi: 0xb6},
+	{value: 0x8132, lo: 0xb7, hi: 0xb8},
+	{value: 0x812d, lo: 0xb9, hi: 0xba},
+	{value: 0x8132, lo: 0xbb, hi: 0xbf},
+	// Block 0x10, offset 0x7a
+	{value: 0x0000, lo: 0x07},
+	{value: 0xa000, lo: 0xa8, hi: 0xa8},
+	{value: 0x3ed8, lo: 0xa9, hi: 0xa9},
+	{value: 0xa000, lo: 0xb0, hi: 0xb0},
+	{value: 0x3ee0, lo: 0xb1, hi: 0xb1},
+	{value: 0xa000, lo: 0xb3, hi: 0xb3},
+	{value: 0x3ee8, lo: 0xb4, hi: 0xb4},
+	{value: 0x9902, lo: 0xbc, hi: 0xbc},
+	// Block 0x11, offset 0x82
+	{value: 0x0008, lo: 0x06},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x8132, lo: 0x91, hi: 0x91},
+	{value: 0x812d, lo: 0x92, hi: 0x92},
+	{value: 0x8132, lo: 0x93, hi: 0x93},
+	{value: 0x8132, lo: 0x94, hi: 0x94},
+	{value: 0x451c, lo: 0x98, hi: 0x9f},
+	// Block 0x12, offset 0x89
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x13, offset 0x8c
+	{value: 0x0008, lo: 0x06},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2c9e, lo: 0x8b, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	{value: 0x455c, lo: 0x9c, hi: 0x9d},
+	{value: 0x456c, lo: 0x9f, hi: 0x9f},
+	// Block 0x14, offset 0x93
+	{value: 0x0000, lo: 0x03},
+	{value: 0x4594, lo: 0xb3, hi: 0xb3},
+	{value: 0x459c, lo: 0xb6, hi: 0xb6},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	// Block 0x15, offset 0x97
+	{value: 0x0008, lo: 0x03},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x4574, lo: 0x99, hi: 0x9b},
+	{value: 0x458c, lo: 0x9e, hi: 0x9e},
+	// Block 0x16, offset 0x9b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	// Block 0x17, offset 0x9d
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	// Block 0x18, offset 0x9f
+	{value: 0x0000, lo: 0x08},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2cb6, lo: 0x88, hi: 0x88},
+	{value: 0x2cae, lo: 0x8b, hi: 0x8b},
+	{value: 0x2cbe, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x96, hi: 0x97},
+	{value: 0x45a4, lo: 0x9c, hi: 0x9c},
+	{value: 0x45ac, lo: 0x9d, hi: 0x9d},
+	// Block 0x19, offset 0xa8
+	{value: 0x0000, lo: 0x03},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x2cc6, lo: 0x94, hi: 0x94},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x1a, offset 0xac
+	{value: 0x0000, lo: 0x06},
+	{value: 0xa000, lo: 0x86, hi: 0x87},
+	{value: 0x2cce, lo: 0x8a, hi: 0x8a},
+	{value: 0x2cde, lo: 0x8b, hi: 0x8b},
+	{value: 0x2cd6, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	// Block 0x1b, offset 0xb3
+	{value: 0x1801, lo: 0x04},
+	{value: 0xa000, lo: 0x86, hi: 0x86},
+	{value: 0x3ef0, lo: 0x88, hi: 0x88},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x8120, lo: 0x95, hi: 0x96},
+	// Block 0x1c, offset 0xb8
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	{value: 0xa000, lo: 0xbf, hi: 0xbf},
+	// Block 0x1d, offset 0xbb
+	{value: 0x0000, lo: 0x09},
+	{value: 0x2ce6, lo: 0x80, hi: 0x80},
+	{value: 0x9900, lo: 0x82, hi: 0x82},
+	{value: 0xa000, lo: 0x86, hi: 0x86},
+	{value: 0x2cee, lo: 0x87, hi: 0x87},
+	{value: 0x2cf6, lo: 0x88, hi: 0x88},
+	{value: 0x2f50, lo: 0x8a, hi: 0x8a},
+	{value: 0x2dd8, lo: 0x8b, hi: 0x8b},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x95, hi: 0x96},
+	// Block 0x1e, offset 0xc5
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xbb, hi: 0xbc},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x1f, offset 0xc8
+	{value: 0x0000, lo: 0x06},
+	{value: 0xa000, lo: 0x86, hi: 0x87},
+	{value: 0x2cfe, lo: 0x8a, hi: 0x8a},
+	{value: 0x2d0e, lo: 0x8b, hi: 0x8b},
+	{value: 0x2d06, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	// Block 0x20, offset 0xcf
+	{value: 0x6bea, lo: 0x07},
+	{value: 0x9904, lo: 0x8a, hi: 0x8a},
+	{value: 0x9900, lo: 0x8f, hi: 0x8f},
+	{value: 0xa000, lo: 0x99, hi: 0x99},
+	{value: 0x3ef8, lo: 0x9a, hi: 0x9a},
+	{value: 0x2f58, lo: 0x9c, hi: 0x9c},
+	{value: 0x2de3, lo: 0x9d, hi: 0x9d},
+	{value: 0x2d16, lo: 0x9e, hi: 0x9f},
+	// Block 0x21, offset 0xd7
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8122, lo: 0xb8, hi: 0xb9},
+	{value: 0x8104, lo: 0xba, hi: 0xba},
+	// Block 0x22, offset 0xda
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8123, lo: 0x88, hi: 0x8b},
+	// Block 0x23, offset 0xdc
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8124, lo: 0xb8, hi: 0xb9},
+	// Block 0x24, offset 0xde
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8125, lo: 0x88, hi: 0x8b},
+	// Block 0x25, offset 0xe0
+	{value: 0x0000, lo: 0x04},
+	{value: 0x812d, lo: 0x98, hi: 0x99},
+	{value: 0x812d, lo: 0xb5, hi: 0xb5},
+	{value: 0x812d, lo: 0xb7, hi: 0xb7},
+	{value: 0x812b, lo: 0xb9, hi: 0xb9},
+	// Block 0x26, offset 0xe5
+	{value: 0x0000, lo: 0x10},
+	{value: 0x2644, lo: 0x83, hi: 0x83},
+	{value: 0x264b, lo: 0x8d, hi: 0x8d},
+	{value: 0x2652, lo: 0x92, hi: 0x92},
+	{value: 0x2659, lo: 0x97, hi: 0x97},
+	{value: 0x2660, lo: 0x9c, hi: 0x9c},
+	{value: 0x263d, lo: 0xa9, hi: 0xa9},
+	{value: 0x8126, lo: 0xb1, hi: 0xb1},
+	{value: 0x8127, lo: 0xb2, hi: 0xb2},
+	{value: 0x4a84, lo: 0xb3, hi: 0xb3},
+	{value: 0x8128, lo: 0xb4, hi: 0xb4},
+	{value: 0x4a8d, lo: 0xb5, hi: 0xb5},
+	{value: 0x45b4, lo: 0xb6, hi: 0xb6},
+	{value: 0x8200, lo: 0xb7, hi: 0xb7},
+	{value: 0x45bc, lo: 0xb8, hi: 0xb8},
+	{value: 0x8200, lo: 0xb9, hi: 0xb9},
+	{value: 0x8127, lo: 0xba, hi: 0xbd},
+	// Block 0x27, offset 0xf6
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x8127, lo: 0x80, hi: 0x80},
+	{value: 0x4a96, lo: 0x81, hi: 0x81},
+	{value: 0x8132, lo: 0x82, hi: 0x83},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0x86, hi: 0x87},
+	{value: 0x266e, lo: 0x93, hi: 0x93},
+	{value: 0x2675, lo: 0x9d, hi: 0x9d},
+	{value: 0x267c, lo: 0xa2, hi: 0xa2},
+	{value: 0x2683, lo: 0xa7, hi: 0xa7},
+	{value: 0x268a, lo: 0xac, hi: 0xac},
+	{value: 0x2667, lo: 0xb9, hi: 0xb9},
+	// Block 0x28, offset 0x102
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x86, hi: 0x86},
+	// Block 0x29, offset 0x104
+	{value: 0x0000, lo: 0x05},
+	{value: 0xa000, lo: 0xa5, hi: 0xa5},
+	{value: 0x2d1e, lo: 0xa6, hi: 0xa6},
+	{value: 0x9900, lo: 0xae, hi: 0xae},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	{value: 0x8104, lo: 0xb9, hi: 0xba},
+	// Block 0x2a, offset 0x10a
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x8d, hi: 0x8d},
+	// Block 0x2b, offset 0x10c
+	{value: 0x0000, lo: 0x01},
+	{value: 0xa000, lo: 0x80, hi: 0x92},
+	// Block 0x2c, offset 0x10e
+	{value: 0x0000, lo: 0x01},
+	{value: 0xb900, lo: 0xa1, hi: 0xb5},
+	// Block 0x2d, offset 0x110
+	{value: 0x0000, lo: 0x01},
+	{value: 0x9900, lo: 0xa8, hi: 0xbf},
+	// Block 0x2e, offset 0x112
+	{value: 0x0000, lo: 0x01},
+	{value: 0x9900, lo: 0x80, hi: 0x82},
+	// Block 0x2f, offset 0x114
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x9d, hi: 0x9f},
+	// Block 0x30, offset 0x116
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x94, hi: 0x94},
+	{value: 0x8104, lo: 0xb4, hi: 0xb4},
+	// Block 0x31, offset 0x119
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x92, hi: 0x92},
+	{value: 0x8132, lo: 0x9d, hi: 0x9d},
+	// Block 0x32, offset 0x11c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8131, lo: 0xa9, hi: 0xa9},
+	// Block 0x33, offset 0x11e
+	{value: 0x0004, lo: 0x02},
+	{value: 0x812e, lo: 0xb9, hi: 0xba},
+	{value: 0x812d, lo: 0xbb, hi: 0xbb},
+	// Block 0x34, offset 0x121
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x97, hi: 0x97},
+	{value: 0x812d, lo: 0x98, hi: 0x98},
+	// Block 0x35, offset 0x124
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8104, lo: 0xa0, hi: 0xa0},
+	{value: 0x8132, lo: 0xb5, hi: 0xbc},
+	{value: 0x812d, lo: 0xbf, hi: 0xbf},
+	// Block 0x36, offset 0x128
+	{value: 0x0000, lo: 0x04},
+	{value: 0x8132, lo: 0xb0, hi: 0xb4},
+	{value: 0x812d, lo: 0xb5, hi: 0xba},
+	{value: 0x8132, lo: 0xbb, hi: 0xbc},
+	{value: 0x812d, lo: 0xbd, hi: 0xbd},
+	// Block 0x37, offset 0x12d
+	{value: 0x0000, lo: 0x08},
+	{value: 0x2d66, lo: 0x80, hi: 0x80},
+	{value: 0x2d6e, lo: 0x81, hi: 0x81},
+	{value: 0xa000, lo: 0x82, hi: 0x82},
+	{value: 0x2d76, lo: 0x83, hi: 0x83},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0xab, hi: 0xab},
+	{value: 0x812d, lo: 0xac, hi: 0xac},
+	{value: 0x8132, lo: 0xad, hi: 0xb3},
+	// Block 0x38, offset 0x136
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xaa, hi: 0xab},
+	// Block 0x39, offset 0x138
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xa6, hi: 0xa6},
+	{value: 0x8104, lo: 0xb2, hi: 0xb3},
+	// Block 0x3a, offset 0x13b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	// Block 0x3b, offset 0x13d
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x8132, lo: 0x90, hi: 0x92},
+	{value: 0x8101, lo: 0x94, hi: 0x94},
+	{value: 0x812d, lo: 0x95, hi: 0x99},
+	{value: 0x8132, lo: 0x9a, hi: 0x9b},
+	{value: 0x812d, lo: 0x9c, hi: 0x9f},
+	{value: 0x8132, lo: 0xa0, hi: 0xa0},
+	{value: 0x8101, lo: 0xa2, hi: 0xa8},
+	{value: 0x812d, lo: 0xad, hi: 0xad},
+	{value: 0x8132, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb8, hi: 0xb9},
+	// Block 0x3c, offset 0x148
+	{value: 0x0004, lo: 0x03},
+	{value: 0x0433, lo: 0x80, hi: 0x81},
+	{value: 0x8100, lo: 0x97, hi: 0x97},
+	{value: 0x8100, lo: 0xbe, hi: 0xbe},
+	// Block 0x3d, offset 0x14c
+	{value: 0x0000, lo: 0x0d},
+	{value: 0x8132, lo: 0x90, hi: 0x91},
+	{value: 0x8101, lo: 0x92, hi: 0x93},
+	{value: 0x8132, lo: 0x94, hi: 0x97},
+	{value: 0x8101, lo: 0x98, hi: 0x9a},
+	{value: 0x8132, lo: 0x9b, hi: 0x9c},
+	{value: 0x8132, lo: 0xa1, hi: 0xa1},
+	{value: 0x8101, lo: 0xa5, hi: 0xa6},
+	{value: 0x8132, lo: 0xa7, hi: 0xa7},
+	{value: 0x812d, lo: 0xa8, hi: 0xa8},
+	{value: 0x8132, lo: 0xa9, hi: 0xa9},
+	{value: 0x8101, lo: 0xaa, hi: 0xab},
+	{value: 0x812d, lo: 0xac, hi: 0xaf},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	// Block 0x3e, offset 0x15a
+	{value: 0x427b, lo: 0x02},
+	{value: 0x01b8, lo: 0xa6, hi: 0xa6},
+	{value: 0x0057, lo: 0xaa, hi: 0xab},
+	// Block 0x3f, offset 0x15d
+	{value: 0x0007, lo: 0x05},
+	{value: 0xa000, lo: 0x90, hi: 0x90},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0xa000, lo: 0x94, hi: 0x94},
+	{value: 0x3bb9, lo: 0x9a, hi: 0x9b},
+	{value: 0x3bc7, lo: 0xae, hi: 0xae},
+	// Block 0x40, offset 0x163
+	{value: 0x000e, lo: 0x05},
+	{value: 0x3bce, lo: 0x8d, hi: 0x8e},
+	{value: 0x3bd5, lo: 0x8f, hi: 0x8f},
+	{value: 0xa000, lo: 0x90, hi: 0x90},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0xa000, lo: 0x94, hi: 0x94},
+	// Block 0x41, offset 0x169
+	{value: 0x6408, lo: 0x0a},
+	{value: 0xa000, lo: 0x83, hi: 0x83},
+	{value: 0x3be3, lo: 0x84, hi: 0x84},
+	{value: 0xa000, lo: 0x88, hi: 0x88},
+	{value: 0x3bea, lo: 0x89, hi: 0x89},
+	{value: 0xa000, lo: 0x8b, hi: 0x8b},
+	{value: 0x3bf1, lo: 0x8c, hi: 0x8c},
+	{value: 0xa000, lo: 0xa3, hi: 0xa3},
+	{value: 0x3bf8, lo: 0xa4, hi: 0xa5},
+	{value: 0x3bff, lo: 0xa6, hi: 0xa6},
+	{value: 0xa000, lo: 0xbc, hi: 0xbc},
+	// Block 0x42, offset 0x174
+	{value: 0x0007, lo: 0x03},
+	{value: 0x3c68, lo: 0xa0, hi: 0xa1},
+	{value: 0x3c92, lo: 0xa2, hi: 0xa3},
+	{value: 0x3cbc, lo: 0xaa, hi: 0xad},
+	// Block 0x43, offset 0x178
+	{value: 0x0004, lo: 0x01},
+	{value: 0x048b, lo: 0xa9, hi: 0xaa},
+	// Block 0x44, offset 0x17a
+	{value: 0x0000, lo: 0x01},
+	{value: 0x44dd, lo: 0x9c, hi: 0x9c},
+	// Block 0x45, offset 0x17c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xaf, hi: 0xb1},
+	// Block 0x46, offset 0x17e
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x47, offset 0x180
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xa0, hi: 0xbf},
+	// Block 0x48, offset 0x182
+	{value: 0x0000, lo: 0x05},
+	{value: 0x812c, lo: 0xaa, hi: 0xaa},
+	{value: 0x8131, lo: 0xab, hi: 0xab},
+	{value: 0x8133, lo: 0xac, hi: 0xac},
+	{value: 0x812e, lo: 0xad, hi: 0xad},
+	{value: 0x812f, lo: 0xae, hi: 0xaf},
+	// Block 0x49, offset 0x188
+	{value: 0x0000, lo: 0x03},
+	{value: 0x4a9f, lo: 0xb3, hi: 0xb3},
+	{value: 0x4a9f, lo: 0xb5, hi: 0xb6},
+	{value: 0x4a9f, lo: 0xba, hi: 0xbf},
+	// Block 0x4a, offset 0x18c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x4a9f, lo: 0x8f, hi: 0xa3},
+	// Block 0x4b, offset 0x18e
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0xae, hi: 0xbe},
+	// Block 0x4c, offset 0x190
+	{value: 0x0000, lo: 0x07},
+	{value: 0x8100, lo: 0x84, hi: 0x84},
+	{value: 0x8100, lo: 0x87, hi: 0x87},
+	{value: 0x8100, lo: 0x90, hi: 0x90},
+	{value: 0x8100, lo: 0x9e, hi: 0x9e},
+	{value: 0x8100, lo: 0xa1, hi: 0xa1},
+	{value: 0x8100, lo: 0xb2, hi: 0xb2},
+	{value: 0x8100, lo: 0xbb, hi: 0xbb},
+	// Block 0x4d, offset 0x198
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8100, lo: 0x80, hi: 0x80},
+	{value: 0x8100, lo: 0x8b, hi: 0x8b},
+	{value: 0x8100, lo: 0x8e, hi: 0x8e},
+	// Block 0x4e, offset 0x19c
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0xaf, hi: 0xaf},
+	{value: 0x8132, lo: 0xb4, hi: 0xbd},
+	// Block 0x4f, offset 0x19f
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x9e, hi: 0x9f},
+	// Block 0x50, offset 0x1a1
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb0, hi: 0xb1},
+	// Block 0x51, offset 0x1a3
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x86, hi: 0x86},
+	// Block 0x52, offset 0x1a5
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0xa0, hi: 0xb1},
+	// Block 0x53, offset 0x1a8
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xab, hi: 0xad},
+	// Block 0x54, offset 0x1aa
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x93, hi: 0x93},
+	// Block 0x55, offset 0x1ac
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xb3, hi: 0xb3},
+	// Block 0x56, offset 0x1ae
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x80, hi: 0x80},
+	// Block 0x57, offset 0x1b0
+	{value: 0x0000, lo: 0x05},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	{value: 0x8132, lo: 0xb2, hi: 0xb3},
+	{value: 0x812d, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb7, hi: 0xb8},
+	{value: 0x8132, lo: 0xbe, hi: 0xbf},
+	// Block 0x58, offset 0x1b6
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x81, hi: 0x81},
+	{value: 0x8104, lo: 0xb6, hi: 0xb6},
+	// Block 0x59, offset 0x1b9
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xad, hi: 0xad},
+	// Block 0x5a, offset 0x1bb
+	{value: 0x0000, lo: 0x06},
+	{value: 0xe500, lo: 0x80, hi: 0x80},
+	{value: 0xc600, lo: 0x81, hi: 0x9b},
+	{value: 0xe500, lo: 0x9c, hi: 0x9c},
+	{value: 0xc600, lo: 0x9d, hi: 0xb7},
+	{value: 0xe500, lo: 0xb8, hi: 0xb8},
+	{value: 0xc600, lo: 0xb9, hi: 0xbf},
+	// Block 0x5b, offset 0x1c2
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x93},
+	{value: 0xe500, lo: 0x94, hi: 0x94},
+	{value: 0xc600, lo: 0x95, hi: 0xaf},
+	{value: 0xe500, lo: 0xb0, hi: 0xb0},
+	{value: 0xc600, lo: 0xb1, hi: 0xbf},
+	// Block 0x5c, offset 0x1c8
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x8b},
+	{value: 0xe500, lo: 0x8c, hi: 0x8c},
+	{value: 0xc600, lo: 0x8d, hi: 0xa7},
+	{value: 0xe500, lo: 0xa8, hi: 0xa8},
+	{value: 0xc600, lo: 0xa9, hi: 0xbf},
+	// Block 0x5d, offset 0x1ce
+	{value: 0x0000, lo: 0x07},
+	{value: 0xc600, lo: 0x80, hi: 0x83},
+	{value: 0xe500, lo: 0x84, hi: 0x84},
+	{value: 0xc600, lo: 0x85, hi: 0x9f},
+	{value: 0xe500, lo: 0xa0, hi: 0xa0},
+	{value: 0xc600, lo: 0xa1, hi: 0xbb},
+	{value: 0xe500, lo: 0xbc, hi: 0xbc},
+	{value: 0xc600, lo: 0xbd, hi: 0xbf},
+	// Block 0x5e, offset 0x1d6
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x97},
+	{value: 0xe500, lo: 0x98, hi: 0x98},
+	{value: 0xc600, lo: 0x99, hi: 0xb3},
+	{value: 0xe500, lo: 0xb4, hi: 0xb4},
+	{value: 0xc600, lo: 0xb5, hi: 0xbf},
+	// Block 0x5f, offset 0x1dc
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x8f},
+	{value: 0xe500, lo: 0x90, hi: 0x90},
+	{value: 0xc600, lo: 0x91, hi: 0xab},
+	{value: 0xe500, lo: 0xac, hi: 0xac},
+	{value: 0xc600, lo: 0xad, hi: 0xbf},
+	// Block 0x60, offset 0x1e2
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x87},
+	{value: 0xe500, lo: 0x88, hi: 0x88},
+	{value: 0xc600, lo: 0x89, hi: 0xa3},
+	{value: 0xe500, lo: 0xa4, hi: 0xa4},
+	{value: 0xc600, lo: 0xa5, hi: 0xbf},
+	// Block 0x61, offset 0x1e8
+	{value: 0x0000, lo: 0x03},
+	{value: 0xc600, lo: 0x80, hi: 0x87},
+	{value: 0xe500, lo: 0x88, hi: 0x88},
+	{value: 0xc600, lo: 0x89, hi: 0xa3},
+	// Block 0x62, offset 0x1ec
+	{value: 0x0006, lo: 0x0d},
+	{value: 0x4390, lo: 0x9d, hi: 0x9d},
+	{value: 0x8115, lo: 0x9e, hi: 0x9e},
+	{value: 0x4402, lo: 0x9f, hi: 0x9f},
+	{value: 0x43f0, lo: 0xaa, hi: 0xab},
+	{value: 0x44f4, lo: 0xac, hi: 0xac},
+	{value: 0x44fc, lo: 0xad, hi: 0xad},
+	{value: 0x4348, lo: 0xae, hi: 0xb1},
+	{value: 0x4366, lo: 0xb2, hi: 0xb4},
+	{value: 0x437e, lo: 0xb5, hi: 0xb6},
+	{value: 0x438a, lo: 0xb8, hi: 0xb8},
+	{value: 0x4396, lo: 0xb9, hi: 0xbb},
+	{value: 0x43ae, lo: 0xbc, hi: 0xbc},
+	{value: 0x43b4, lo: 0xbe, hi: 0xbe},
+	// Block 0x63, offset 0x1fa
+	{value: 0x0006, lo: 0x08},
+	{value: 0x43ba, lo: 0x80, hi: 0x81},
+	{value: 0x43c6, lo: 0x83, hi: 0x84},
+	{value: 0x43d8, lo: 0x86, hi: 0x89},
+	{value: 0x43fc, lo: 0x8a, hi: 0x8a},
+	{value: 0x4378, lo: 0x8b, hi: 0x8b},
+	{value: 0x4360, lo: 0x8c, hi: 0x8c},
+	{value: 0x43a8, lo: 0x8d, hi: 0x8d},
+	{value: 0x43d2, lo: 0x8e, hi: 0x8e},
+	// Block 0x64, offset 0x203
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8100, lo: 0xa4, hi: 0xa5},
+	{value: 0x8100, lo: 0xb0, hi: 0xb1},
+	// Block 0x65, offset 0x206
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8100, lo: 0x9b, hi: 0x9d},
+	{value: 0x8200, lo: 0x9e, hi: 0xa3},
+	// Block 0x66, offset 0x209
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0x90, hi: 0x90},
+	// Block 0x67, offset 0x20b
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8100, lo: 0x99, hi: 0x99},
+	{value: 0x8200, lo: 0xb2, hi: 0xb4},
+	// Block 0x68, offset 0x20e
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0xbc, hi: 0xbd},
+	// Block 0x69, offset 0x210
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8132, lo: 0xa0, hi: 0xa6},
+	{value: 0x812d, lo: 0xa7, hi: 0xad},
+	{value: 0x8132, lo: 0xae, hi: 0xaf},
+	// Block 0x6a, offset 0x214
+	{value: 0x0000, lo: 0x04},
+	{value: 0x8100, lo: 0x89, hi: 0x8c},
+	{value: 0x8100, lo: 0xb0, hi: 0xb2},
+	{value: 0x8100, lo: 0xb4, hi: 0xb4},
+	{value: 0x8100, lo: 0xb6, hi: 0xbf},
+	// Block 0x6b, offset 0x219
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0x81, hi: 0x8c},
+	// Block 0x6c, offset 0x21b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0xb5, hi: 0xba},
+	// Block 0x6d, offset 0x21d
+	{value: 0x0000, lo: 0x04},
+	{value: 0x4a9f, lo: 0x9e, hi: 0x9f},
+	{value: 0x4a9f, lo: 0xa3, hi: 0xa3},
+	{value: 0x4a9f, lo: 0xa5, hi: 0xa6},
+	{value: 0x4a9f, lo: 0xaa, hi: 0xaf},
+	// Block 0x6e, offset 0x222
+	{value: 0x0000, lo: 0x05},
+	{value: 0x4a9f, lo: 0x82, hi: 0x87},
+	{value: 0x4a9f, lo: 0x8a, hi: 0x8f},
+	{value: 0x4a9f, lo: 0x92, hi: 0x97},
+	{value: 0x4a9f, lo: 0x9a, hi: 0x9c},
+	{value: 0x8100, lo: 0xa3, hi: 0xa3},
+	// Block 0x6f, offset 0x228
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xbd, hi: 0xbd},
+	// Block 0x70, offset 0x22a
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xa0, hi: 0xa0},
+	// Block 0x71, offset 0x22c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb6, hi: 0xba},
+	// Block 0x72, offset 0x22e
+	{value: 0x002c, lo: 0x05},
+	{value: 0x812d, lo: 0x8d, hi: 0x8d},
+	{value: 0x8132, lo: 0x8f, hi: 0x8f},
+	{value: 0x8132, lo: 0xb8, hi: 0xb8},
+	{value: 0x8101, lo: 0xb9, hi: 0xba},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x73, offset 0x234
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0xa5, hi: 0xa5},
+	{value: 0x812d, lo: 0xa6, hi: 0xa6},
+	// Block 0x74, offset 0x237
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x86, hi: 0x86},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x75, offset 0x23a
+	{value: 0x17fe, lo: 0x07},
+	{value: 0xa000, lo: 0x99, hi: 0x99},
+	{value: 0x4238, lo: 0x9a, hi: 0x9a},
+	{value: 0xa000, lo: 0x9b, hi: 0x9b},
+	{value: 0x4242, lo: 0x9c, hi: 0x9c},
+	{value: 0xa000, lo: 0xa5, hi: 0xa5},
+	{value: 0x424c, lo: 0xab, hi: 0xab},
+	{value: 0x8104, lo: 0xb9, hi: 0xba},
+	// Block 0x76, offset 0x242
+	{value: 0x0000, lo: 0x06},
+	{value: 0x8132, lo: 0x80, hi: 0x82},
+	{value: 0x9900, lo: 0xa7, hi: 0xa7},
+	{value: 0x2d7e, lo: 0xae, hi: 0xae},
+	{value: 0x2d88, lo: 0xaf, hi: 0xaf},
+	{value: 0xa000, lo: 0xb1, hi: 0xb2},
+	{value: 0x8104, lo: 0xb3, hi: 0xb4},
+	// Block 0x77, offset 0x249
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x80, hi: 0x80},
+	{value: 0x8102, lo: 0x8a, hi: 0x8a},
+	// Block 0x78, offset 0x24c
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xb5, hi: 0xb5},
+	{value: 0x8102, lo: 0xb6, hi: 0xb6},
+	// Block 0x79, offset 0x24f
+	{value: 0x0002, lo: 0x01},
+	{value: 0x8102, lo: 0xa9, hi: 0xaa},
+	// Block 0x7a, offset 0x251
+	{value: 0x0000, lo: 0x07},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2d92, lo: 0x8b, hi: 0x8b},
+	{value: 0x2d9c, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	{value: 0x8132, lo: 0xa6, hi: 0xac},
+	{value: 0x8132, lo: 0xb0, hi: 0xb4},
+	// Block 0x7b, offset 0x259
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x82, hi: 0x82},
+	{value: 0x8102, lo: 0x86, hi: 0x86},
+	// Block 0x7c, offset 0x25c
+	{value: 0x6b5a, lo: 0x06},
+	{value: 0x9900, lo: 0xb0, hi: 0xb0},
+	{value: 0xa000, lo: 0xb9, hi: 0xb9},
+	{value: 0x9900, lo: 0xba, hi: 0xba},
+	{value: 0x2db0, lo: 0xbb, hi: 0xbb},
+	{value: 0x2da6, lo: 0xbc, hi: 0xbd},
+	{value: 0x2dba, lo: 0xbe, hi: 0xbe},
+	// Block 0x7d, offset 0x263
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x82, hi: 0x82},
+	{value: 0x8102, lo: 0x83, hi: 0x83},
+	// Block 0x7e, offset 0x266
+	{value: 0x0000, lo: 0x05},
+	{value: 0x9900, lo: 0xaf, hi: 0xaf},
+	{value: 0xa000, lo: 0xb8, hi: 0xb9},
+	{value: 0x2dc4, lo: 0xba, hi: 0xba},
+	{value: 0x2dce, lo: 0xbb, hi: 0xbb},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x7f, offset 0x26c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0x80, hi: 0x80},
+	// Block 0x80, offset 0x26e
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xb6, hi: 0xb6},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	// Block 0x81, offset 0x271
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xab, hi: 0xab},
+	// Block 0x82, offset 0x273
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xb4, hi: 0xb4},
+	// Block 0x83, offset 0x275
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x87, hi: 0x87},
+	// Block 0x84, offset 0x277
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x99, hi: 0x99},
+	// Block 0x85, offset 0x279
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0x82, hi: 0x82},
+	{value: 0x8104, lo: 0x84, hi: 0x85},
+	// Block 0x86, offset 0x27c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8101, lo: 0xb0, hi: 0xb4},
+	// Block 0x87, offset 0x27e
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb0, hi: 0xb6},
+	// Block 0x88, offset 0x280
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8101, lo: 0x9e, hi: 0x9e},
+	// Block 0x89, offset 0x282
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x45cc, lo: 0x9e, hi: 0x9e},
+	{value: 0x45d6, lo: 0x9f, hi: 0x9f},
+	{value: 0x460a, lo: 0xa0, hi: 0xa0},
+	{value: 0x4618, lo: 0xa1, hi: 0xa1},
+	{value: 0x4626, lo: 0xa2, hi: 0xa2},
+	{value: 0x4634, lo: 0xa3, hi: 0xa3},
+	{value: 0x4642, lo: 0xa4, hi: 0xa4},
+	{value: 0x812b, lo: 0xa5, hi: 0xa6},
+	{value: 0x8101, lo: 0xa7, hi: 0xa9},
+	{value: 0x8130, lo: 0xad, hi: 0xad},
+	{value: 0x812b, lo: 0xae, hi: 0xb2},
+	{value: 0x812d, lo: 0xbb, hi: 0xbf},
+	// Block 0x8a, offset 0x28f
+	{value: 0x0000, lo: 0x09},
+	{value: 0x812d, lo: 0x80, hi: 0x82},
+	{value: 0x8132, lo: 0x85, hi: 0x89},
+	{value: 0x812d, lo: 0x8a, hi: 0x8b},
+	{value: 0x8132, lo: 0xaa, hi: 0xad},
+	{value: 0x45e0, lo: 0xbb, hi: 0xbb},
+	{value: 0x45ea, lo: 0xbc, hi: 0xbc},
+	{value: 0x4650, lo: 0xbd, hi: 0xbd},
+	{value: 0x466c, lo: 0xbe, hi: 0xbe},
+	{value: 0x465e, lo: 0xbf, hi: 0xbf},
+	// Block 0x8b, offset 0x299
+	{value: 0x0000, lo: 0x01},
+	{value: 0x467a, lo: 0x80, hi: 0x80},
+	// Block 0x8c, offset 0x29b
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x82, hi: 0x84},
+	// Block 0x8d, offset 0x29d
+	{value: 0x0000, lo: 0x05},
+	{value: 0x8132, lo: 0x80, hi: 0x86},
+	{value: 0x8132, lo: 0x88, hi: 0x98},
+	{value: 0x8132, lo: 0x9b, hi: 0xa1},
+	{value: 0x8132, lo: 0xa3, hi: 0xa4},
+	{value: 0x8132, lo: 0xa6, hi: 0xaa},
+	// Block 0x8e, offset 0x2a3
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x90, hi: 0x96},
+	// Block 0x8f, offset 0x2a5
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x84, hi: 0x89},
+	{value: 0x8102, lo: 0x8a, hi: 0x8a},
+	// Block 0x90, offset 0x2a8
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8100, lo: 0x93, hi: 0x93},
+}
+
+// lookup returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *nfkcTrie) lookup(s []byte) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return nfkcValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfkcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfkcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = nfkcIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *nfkcTrie) lookupUnsafe(s []byte) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return nfkcValues[c0]
+	}
+	i := nfkcIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = nfkcIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = nfkcIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// lookupString returns the trie value for the first UTF-8 encoding in s and
+// the width in bytes of this encoding. The size will be 0 if s does not
+// hold enough bytes to complete the encoding. len(s) must be greater than 0.
+func (t *nfkcTrie) lookupString(s string) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return nfkcValues[c0], 1
+	case c0 < 0xC2:
+		return 0, 1 // Illegal UTF-8: not a starter, not ASCII.
+	case c0 < 0xE0: // 2-byte UTF-8
+		if len(s) < 2 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c1), 2
+	case c0 < 0xF0: // 3-byte UTF-8
+		if len(s) < 3 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfkcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c2), 3
+	case c0 < 0xF8: // 4-byte UTF-8
+		if len(s) < 4 {
+			return 0, 0
+		}
+		i := nfkcIndex[c0]
+		c1 := s[1]
+		if c1 < 0x80 || 0xC0 <= c1 {
+			return 0, 1 // Illegal UTF-8: not a continuation byte.
+		}
+		o := uint32(i)<<6 + uint32(c1)
+		i = nfkcIndex[o]
+		c2 := s[2]
+		if c2 < 0x80 || 0xC0 <= c2 {
+			return 0, 2 // Illegal UTF-8: not a continuation byte.
+		}
+		o = uint32(i)<<6 + uint32(c2)
+		i = nfkcIndex[o]
+		c3 := s[3]
+		if c3 < 0x80 || 0xC0 <= c3 {
+			return 0, 3 // Illegal UTF-8: not a continuation byte.
+		}
+		return t.lookupValue(uint32(i), c3), 4
+	}
+	// Illegal rune
+	return 0, 1
+}
+
+// lookupStringUnsafe returns the trie value for the first UTF-8 encoding in s.
+// s must start with a full and valid UTF-8 encoded rune.
+func (t *nfkcTrie) lookupStringUnsafe(s string) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return nfkcValues[c0]
+	}
+	i := nfkcIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = nfkcIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = nfkcIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// nfkcTrie. Total size: 17104 bytes (16.70 KiB). Checksum: d985061cf5307b35.
+type nfkcTrie struct{}
+
+func newNfkcTrie(i int) *nfkcTrie {
+	return &nfkcTrie{}
+}
+
+// lookupValue determines the type of block n and looks up the value for b.
+func (t *nfkcTrie) lookupValue(n uint32, b byte) uint16 {
+	switch {
+	case n < 91:
+		return uint16(nfkcValues[n<<6+uint32(b)])
+	default:
+		n -= 91
+		return uint16(nfkcSparse.lookup(n, b))
+	}
+}
+
+// nfkcValues: 93 blocks, 5952 entries, 11904 bytes
+// The third block is the zero block.
+var nfkcValues = [5952]uint16{
+	// Block 0x0, offset 0x0
+	0x3c: 0xa000, 0x3d: 0xa000, 0x3e: 0xa000,
+	// Block 0x1, offset 0x40
+	0x41: 0xa000, 0x42: 0xa000, 0x43: 0xa000, 0x44: 0xa000, 0x45: 0xa000,
+	0x46: 0xa000, 0x47: 0xa000, 0x48: 0xa000, 0x49: 0xa000, 0x4a: 0xa000, 0x4b: 0xa000,
+	0x4c: 0xa000, 0x4d: 0xa000, 0x4e: 0xa000, 0x4f: 0xa000, 0x50: 0xa000,
+	0x52: 0xa000, 0x53: 0xa000, 0x54: 0xa000, 0x55: 0xa000, 0x56: 0xa000, 0x57: 0xa000,
+	0x58: 0xa000, 0x59: 0xa000, 0x5a: 0xa000,
+	0x61: 0xa000, 0x62: 0xa000, 0x63: 0xa000,
+	0x64: 0xa000, 0x65: 0xa000, 0x66: 0xa000, 0x67: 0xa000, 0x68: 0xa000, 0x69: 0xa000,
+	0x6a: 0xa000, 0x6b: 0xa000, 0x6c: 0xa000, 0x6d: 0xa000, 0x6e: 0xa000, 0x6f: 0xa000,
+	0x70: 0xa000, 0x72: 0xa000, 0x73: 0xa000, 0x74: 0xa000, 0x75: 0xa000,
+	0x76: 0xa000, 0x77: 0xa000, 0x78: 0xa000, 0x79: 0xa000, 0x7a: 0xa000,
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc0: 0x2f6f, 0xc1: 0x2f74, 0xc2: 0x4688, 0xc3: 0x2f79, 0xc4: 0x4697, 0xc5: 0x469c,
+	0xc6: 0xa000, 0xc7: 0x46a6, 0xc8: 0x2fe2, 0xc9: 0x2fe7, 0xca: 0x46ab, 0xcb: 0x2ffb,
+	0xcc: 0x306e, 0xcd: 0x3073, 0xce: 0x3078, 0xcf: 0x46bf, 0xd1: 0x3104,
+	0xd2: 0x3127, 0xd3: 0x312c, 0xd4: 0x46c9, 0xd5: 0x46ce, 0xd6: 0x46dd,
+	0xd8: 0xa000, 0xd9: 0x31b3, 0xda: 0x31b8, 0xdb: 0x31bd, 0xdc: 0x470f, 0xdd: 0x3235,
+	0xe0: 0x327b, 0xe1: 0x3280, 0xe2: 0x4719, 0xe3: 0x3285,
+	0xe4: 0x4728, 0xe5: 0x472d, 0xe6: 0xa000, 0xe7: 0x4737, 0xe8: 0x32ee, 0xe9: 0x32f3,
+	0xea: 0x473c, 0xeb: 0x3307, 0xec: 0x337f, 0xed: 0x3384, 0xee: 0x3389, 0xef: 0x4750,
+	0xf1: 0x3415, 0xf2: 0x3438, 0xf3: 0x343d, 0xf4: 0x475a, 0xf5: 0x475f,
+	0xf6: 0x476e, 0xf8: 0xa000, 0xf9: 0x34c9, 0xfa: 0x34ce, 0xfb: 0x34d3,
+	0xfc: 0x47a0, 0xfd: 0x3550, 0xff: 0x3569,
+	// Block 0x4, offset 0x100
+	0x100: 0x2f7e, 0x101: 0x328a, 0x102: 0x468d, 0x103: 0x471e, 0x104: 0x2f9c, 0x105: 0x32a8,
+	0x106: 0x2fb0, 0x107: 0x32bc, 0x108: 0x2fb5, 0x109: 0x32c1, 0x10a: 0x2fba, 0x10b: 0x32c6,
+	0x10c: 0x2fbf, 0x10d: 0x32cb, 0x10e: 0x2fc9, 0x10f: 0x32d5,
+	0x112: 0x46b0, 0x113: 0x4741, 0x114: 0x2ff1, 0x115: 0x32fd, 0x116: 0x2ff6, 0x117: 0x3302,
+	0x118: 0x3014, 0x119: 0x3320, 0x11a: 0x3005, 0x11b: 0x3311, 0x11c: 0x302d, 0x11d: 0x3339,
+	0x11e: 0x3037, 0x11f: 0x3343, 0x120: 0x303c, 0x121: 0x3348, 0x122: 0x3046, 0x123: 0x3352,
+	0x124: 0x304b, 0x125: 0x3357, 0x128: 0x307d, 0x129: 0x338e,
+	0x12a: 0x3082, 0x12b: 0x3393, 0x12c: 0x3087, 0x12d: 0x3398, 0x12e: 0x30aa, 0x12f: 0x33b6,
+	0x130: 0x308c, 0x132: 0x195d, 0x133: 0x19e7, 0x134: 0x30b4, 0x135: 0x33c0,
+	0x136: 0x30c8, 0x137: 0x33d9, 0x139: 0x30d2, 0x13a: 0x33e3, 0x13b: 0x30dc,
+	0x13c: 0x33ed, 0x13d: 0x30d7, 0x13e: 0x33e8, 0x13f: 0x1bac,
+	// Block 0x5, offset 0x140
+	0x140: 0x1c34, 0x143: 0x30ff, 0x144: 0x3410, 0x145: 0x3118,
+	0x146: 0x3429, 0x147: 0x310e, 0x148: 0x341f, 0x149: 0x1c5c,
+	0x14c: 0x46d3, 0x14d: 0x4764, 0x14e: 0x3131, 0x14f: 0x3442, 0x150: 0x313b, 0x151: 0x344c,
+	0x154: 0x3159, 0x155: 0x346a, 0x156: 0x3172, 0x157: 0x3483,
+	0x158: 0x3163, 0x159: 0x3474, 0x15a: 0x46f6, 0x15b: 0x4787, 0x15c: 0x317c, 0x15d: 0x348d,
+	0x15e: 0x318b, 0x15f: 0x349c, 0x160: 0x46fb, 0x161: 0x478c, 0x162: 0x31a4, 0x163: 0x34ba,
+	0x164: 0x3195, 0x165: 0x34ab, 0x168: 0x4705, 0x169: 0x4796,
+	0x16a: 0x470a, 0x16b: 0x479b, 0x16c: 0x31c2, 0x16d: 0x34d8, 0x16e: 0x31cc, 0x16f: 0x34e2,
+	0x170: 0x31d1, 0x171: 0x34e7, 0x172: 0x31ef, 0x173: 0x3505, 0x174: 0x3212, 0x175: 0x3528,
+	0x176: 0x323a, 0x177: 0x3555, 0x178: 0x324e, 0x179: 0x325d, 0x17a: 0x357d, 0x17b: 0x3267,
+	0x17c: 0x3587, 0x17d: 0x326c, 0x17e: 0x358c, 0x17f: 0x00a7,
+	// Block 0x6, offset 0x180
+	0x184: 0x2dee, 0x185: 0x2df4,
+	0x186: 0x2dfa, 0x187: 0x1972, 0x188: 0x1975, 0x189: 0x1a08, 0x18a: 0x1987, 0x18b: 0x198a,
+	0x18c: 0x1a3e, 0x18d: 0x2f88, 0x18e: 0x3294, 0x18f: 0x3096, 0x190: 0x33a2, 0x191: 0x3140,
+	0x192: 0x3451, 0x193: 0x31d6, 0x194: 0x34ec, 0x195: 0x39cf, 0x196: 0x3b5e, 0x197: 0x39c8,
+	0x198: 0x3b57, 0x199: 0x39d6, 0x19a: 0x3b65, 0x19b: 0x39c1, 0x19c: 0x3b50,
+	0x19e: 0x38b0, 0x19f: 0x3a3f, 0x1a0: 0x38a9, 0x1a1: 0x3a38, 0x1a2: 0x35b3, 0x1a3: 0x35c5,
+	0x1a6: 0x3041, 0x1a7: 0x334d, 0x1a8: 0x30be, 0x1a9: 0x33cf,
+	0x1aa: 0x46ec, 0x1ab: 0x477d, 0x1ac: 0x3990, 0x1ad: 0x3b1f, 0x1ae: 0x35d7, 0x1af: 0x35dd,
+	0x1b0: 0x33c5, 0x1b1: 0x1942, 0x1b2: 0x1945, 0x1b3: 0x19cf, 0x1b4: 0x3028, 0x1b5: 0x3334,
+	0x1b8: 0x30fa, 0x1b9: 0x340b, 0x1ba: 0x38b7, 0x1bb: 0x3a46,
+	0x1bc: 0x35ad, 0x1bd: 0x35bf, 0x1be: 0x35b9, 0x1bf: 0x35cb,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x2f8d, 0x1c1: 0x3299, 0x1c2: 0x2f92, 0x1c3: 0x329e, 0x1c4: 0x300a, 0x1c5: 0x3316,
+	0x1c6: 0x300f, 0x1c7: 0x331b, 0x1c8: 0x309b, 0x1c9: 0x33a7, 0x1ca: 0x30a0, 0x1cb: 0x33ac,
+	0x1cc: 0x3145, 0x1cd: 0x3456, 0x1ce: 0x314a, 0x1cf: 0x345b, 0x1d0: 0x3168, 0x1d1: 0x3479,
+	0x1d2: 0x316d, 0x1d3: 0x347e, 0x1d4: 0x31db, 0x1d5: 0x34f1, 0x1d6: 0x31e0, 0x1d7: 0x34f6,
+	0x1d8: 0x3186, 0x1d9: 0x3497, 0x1da: 0x319f, 0x1db: 0x34b5,
+	0x1de: 0x305a, 0x1df: 0x3366,
+	0x1e6: 0x4692, 0x1e7: 0x4723, 0x1e8: 0x46ba, 0x1e9: 0x474b,
+	0x1ea: 0x395f, 0x1eb: 0x3aee, 0x1ec: 0x393c, 0x1ed: 0x3acb, 0x1ee: 0x46d8, 0x1ef: 0x4769,
+	0x1f0: 0x3958, 0x1f1: 0x3ae7, 0x1f2: 0x3244, 0x1f3: 0x355f,
+	// Block 0x8, offset 0x200
+	0x200: 0x9932, 0x201: 0x9932, 0x202: 0x9932, 0x203: 0x9932, 0x204: 0x9932, 0x205: 0x8132,
+	0x206: 0x9932, 0x207: 0x9932, 0x208: 0x9932, 0x209: 0x9932, 0x20a: 0x9932, 0x20b: 0x9932,
+	0x20c: 0x9932, 0x20d: 0x8132, 0x20e: 0x8132, 0x20f: 0x9932, 0x210: 0x8132, 0x211: 0x9932,
+	0x212: 0x8132, 0x213: 0x9932, 0x214: 0x9932, 0x215: 0x8133, 0x216: 0x812d, 0x217: 0x812d,
+	0x218: 0x812d, 0x219: 0x812d, 0x21a: 0x8133, 0x21b: 0x992b, 0x21c: 0x812d, 0x21d: 0x812d,
+	0x21e: 0x812d, 0x21f: 0x812d, 0x220: 0x812d, 0x221: 0x8129, 0x222: 0x8129, 0x223: 0x992d,
+	0x224: 0x992d, 0x225: 0x992d, 0x226: 0x992d, 0x227: 0x9929, 0x228: 0x9929, 0x229: 0x812d,
+	0x22a: 0x812d, 0x22b: 0x812d, 0x22c: 0x812d, 0x22d: 0x992d, 0x22e: 0x992d, 0x22f: 0x812d,
+	0x230: 0x992d, 0x231: 0x992d, 0x232: 0x812d, 0x233: 0x812d, 0x234: 0x8101, 0x235: 0x8101,
+	0x236: 0x8101, 0x237: 0x8101, 0x238: 0x9901, 0x239: 0x812d, 0x23a: 0x812d, 0x23b: 0x812d,
+	0x23c: 0x812d, 0x23d: 0x8132, 0x23e: 0x8132, 0x23f: 0x8132,
+	// Block 0x9, offset 0x240
+	0x240: 0x49ae, 0x241: 0x49b3, 0x242: 0x9932, 0x243: 0x49b8, 0x244: 0x4a71, 0x245: 0x9936,
+	0x246: 0x8132, 0x247: 0x812d, 0x248: 0x812d, 0x249: 0x812d, 0x24a: 0x8132, 0x24b: 0x8132,
+	0x24c: 0x8132, 0x24d: 0x812d, 0x24e: 0x812d, 0x250: 0x8132, 0x251: 0x8132,
+	0x252: 0x8132, 0x253: 0x812d, 0x254: 0x812d, 0x255: 0x812d, 0x256: 0x812d, 0x257: 0x8132,
+	0x258: 0x8133, 0x259: 0x812d, 0x25a: 0x812d, 0x25b: 0x8132, 0x25c: 0x8134, 0x25d: 0x8135,
+	0x25e: 0x8135, 0x25f: 0x8134, 0x260: 0x8135, 0x261: 0x8135, 0x262: 0x8134, 0x263: 0x8132,
+	0x264: 0x8132, 0x265: 0x8132, 0x266: 0x8132, 0x267: 0x8132, 0x268: 0x8132, 0x269: 0x8132,
+	0x26a: 0x8132, 0x26b: 0x8132, 0x26c: 0x8132, 0x26d: 0x8132, 0x26e: 0x8132, 0x26f: 0x8132,
+	0x274: 0x0170,
+	0x27a: 0x42a5,
+	0x27e: 0x0037,
+	// Block 0xa, offset 0x280
+	0x284: 0x425a, 0x285: 0x447b,
+	0x286: 0x35e9, 0x287: 0x00ce, 0x288: 0x3607, 0x289: 0x3613, 0x28a: 0x3625,
+	0x28c: 0x3643, 0x28e: 0x3655, 0x28f: 0x3673, 0x290: 0x3e08, 0x291: 0xa000,
+	0x295: 0xa000, 0x297: 0xa000,
+	0x299: 0xa000,
+	0x29f: 0xa000, 0x2a1: 0xa000,
+	0x2a5: 0xa000, 0x2a9: 0xa000,
+	0x2aa: 0x3637, 0x2ab: 0x3667, 0x2ac: 0x47fe, 0x2ad: 0x3697, 0x2ae: 0x4828, 0x2af: 0x36a9,
+	0x2b0: 0x3e70, 0x2b1: 0xa000, 0x2b5: 0xa000,
+	0x2b7: 0xa000, 0x2b9: 0xa000,
+	0x2bf: 0xa000,
+	// Block 0xb, offset 0x2c0
+	0x2c1: 0xa000, 0x2c5: 0xa000,
+	0x2c9: 0xa000, 0x2ca: 0x4840, 0x2cb: 0x485e,
+	0x2cc: 0x36c7, 0x2cd: 0x36df, 0x2ce: 0x4876, 0x2d0: 0x01be, 0x2d1: 0x01d0,
+	0x2d2: 0x01ac, 0x2d3: 0x430c, 0x2d4: 0x4312, 0x2d5: 0x01fa, 0x2d6: 0x01e8,
+	0x2f0: 0x01d6, 0x2f1: 0x01eb, 0x2f2: 0x01ee, 0x2f4: 0x0188, 0x2f5: 0x01c7,
+	0x2f9: 0x01a6,
+	// Block 0xc, offset 0x300
+	0x300: 0x3721, 0x301: 0x372d, 0x303: 0x371b,
+	0x306: 0xa000, 0x307: 0x3709,
+	0x30c: 0x375d, 0x30d: 0x3745, 0x30e: 0x376f, 0x310: 0xa000,
+	0x313: 0xa000, 0x315: 0xa000, 0x316: 0xa000, 0x317: 0xa000,
+	0x318: 0xa000, 0x319: 0x3751, 0x31a: 0xa000,
+	0x31e: 0xa000, 0x323: 0xa000,
+	0x327: 0xa000,
+	0x32b: 0xa000, 0x32d: 0xa000,
+	0x330: 0xa000, 0x333: 0xa000, 0x335: 0xa000,
+	0x336: 0xa000, 0x337: 0xa000, 0x338: 0xa000, 0x339: 0x37d5, 0x33a: 0xa000,
+	0x33e: 0xa000,
+	// Block 0xd, offset 0x340
+	0x341: 0x3733, 0x342: 0x37b7,
+	0x350: 0x370f, 0x351: 0x3793,
+	0x352: 0x3715, 0x353: 0x3799, 0x356: 0x3727, 0x357: 0x37ab,
+	0x358: 0xa000, 0x359: 0xa000, 0x35a: 0x3829, 0x35b: 0x382f, 0x35c: 0x3739, 0x35d: 0x37bd,
+	0x35e: 0x373f, 0x35f: 0x37c3, 0x362: 0x374b, 0x363: 0x37cf,
+	0x364: 0x3757, 0x365: 0x37db, 0x366: 0x3763, 0x367: 0x37e7, 0x368: 0xa000, 0x369: 0xa000,
+	0x36a: 0x3835, 0x36b: 0x383b, 0x36c: 0x378d, 0x36d: 0x3811, 0x36e: 0x3769, 0x36f: 0x37ed,
+	0x370: 0x3775, 0x371: 0x37f9, 0x372: 0x377b, 0x373: 0x37ff, 0x374: 0x3781, 0x375: 0x3805,
+	0x378: 0x3787, 0x379: 0x380b,
+	// Block 0xe, offset 0x380
+	0x387: 0x1d61,
+	0x391: 0x812d,
+	0x392: 0x8132, 0x393: 0x8132, 0x394: 0x8132, 0x395: 0x8132, 0x396: 0x812d, 0x397: 0x8132,
+	0x398: 0x8132, 0x399: 0x8132, 0x39a: 0x812e, 0x39b: 0x812d, 0x39c: 0x8132, 0x39d: 0x8132,
+	0x39e: 0x8132, 0x39f: 0x8132, 0x3a0: 0x8132, 0x3a1: 0x8132, 0x3a2: 0x812d, 0x3a3: 0x812d,
+	0x3a4: 0x812d, 0x3a5: 0x812d, 0x3a6: 0x812d, 0x3a7: 0x812d, 0x3a8: 0x8132, 0x3a9: 0x8132,
+	0x3aa: 0x812d, 0x3ab: 0x8132, 0x3ac: 0x8132, 0x3ad: 0x812e, 0x3ae: 0x8131, 0x3af: 0x8132,
+	0x3b0: 0x8105, 0x3b1: 0x8106, 0x3b2: 0x8107, 0x3b3: 0x8108, 0x3b4: 0x8109, 0x3b5: 0x810a,
+	0x3b6: 0x810b, 0x3b7: 0x810c, 0x3b8: 0x810d, 0x3b9: 0x810e, 0x3ba: 0x810e, 0x3bb: 0x810f,
+	0x3bc: 0x8110, 0x3bd: 0x8111, 0x3bf: 0x8112,
+	// Block 0xf, offset 0x3c0
+	0x3c8: 0xa000, 0x3ca: 0xa000, 0x3cb: 0x8116,
+	0x3cc: 0x8117, 0x3cd: 0x8118, 0x3ce: 0x8119, 0x3cf: 0x811a, 0x3d0: 0x811b, 0x3d1: 0x811c,
+	0x3d2: 0x811d, 0x3d3: 0x9932, 0x3d4: 0x9932, 0x3d5: 0x992d, 0x3d6: 0x812d, 0x3d7: 0x8132,
+	0x3d8: 0x8132, 0x3d9: 0x8132, 0x3da: 0x8132, 0x3db: 0x8132, 0x3dc: 0x812d, 0x3dd: 0x8132,
+	0x3de: 0x8132, 0x3df: 0x812d,
+	0x3f0: 0x811e, 0x3f5: 0x1d84,
+	0x3f6: 0x2013, 0x3f7: 0x204f, 0x3f8: 0x204a,
+	// Block 0x10, offset 0x400
+	0x405: 0xa000,
+	0x406: 0x2d26, 0x407: 0xa000, 0x408: 0x2d2e, 0x409: 0xa000, 0x40a: 0x2d36, 0x40b: 0xa000,
+	0x40c: 0x2d3e, 0x40d: 0xa000, 0x40e: 0x2d46, 0x411: 0xa000,
+	0x412: 0x2d4e,
+	0x434: 0x8102, 0x435: 0x9900,
+	0x43a: 0xa000, 0x43b: 0x2d56,
+	0x43c: 0xa000, 0x43d: 0x2d5e, 0x43e: 0xa000, 0x43f: 0xa000,
+	// Block 0x11, offset 0x440
+	0x440: 0x0069, 0x441: 0x006b, 0x442: 0x006f, 0x443: 0x0083, 0x444: 0x00f5, 0x445: 0x00f8,
+	0x446: 0x0413, 0x447: 0x0085, 0x448: 0x0089, 0x449: 0x008b, 0x44a: 0x0104, 0x44b: 0x0107,
+	0x44c: 0x010a, 0x44d: 0x008f, 0x44f: 0x0097, 0x450: 0x009b, 0x451: 0x00e0,
+	0x452: 0x009f, 0x453: 0x00fe, 0x454: 0x0417, 0x455: 0x041b, 0x456: 0x00a1, 0x457: 0x00a9,
+	0x458: 0x00ab, 0x459: 0x0423, 0x45a: 0x012b, 0x45b: 0x00ad, 0x45c: 0x0427, 0x45d: 0x01be,
+	0x45e: 0x01c1, 0x45f: 0x01c4, 0x460: 0x01fa, 0x461: 0x01fd, 0x462: 0x0093, 0x463: 0x00a5,
+	0x464: 0x00ab, 0x465: 0x00ad, 0x466: 0x01be, 0x467: 0x01c1, 0x468: 0x01eb, 0x469: 0x01fa,
+	0x46a: 0x01fd,
+	0x478: 0x020c,
+	// Block 0x12, offset 0x480
+	0x49b: 0x00fb, 0x49c: 0x0087, 0x49d: 0x0101,
+	0x49e: 0x00d4, 0x49f: 0x010a, 0x4a0: 0x008d, 0x4a1: 0x010d, 0x4a2: 0x0110, 0x4a3: 0x0116,
+	0x4a4: 0x011c, 0x4a5: 0x011f, 0x4a6: 0x0122, 0x4a7: 0x042b, 0x4a8: 0x016a, 0x4a9: 0x0128,
+	0x4aa: 0x042f, 0x4ab: 0x016d, 0x4ac: 0x0131, 0x4ad: 0x012e, 0x4ae: 0x0134, 0x4af: 0x0137,
+	0x4b0: 0x013a, 0x4b1: 0x013d, 0x4b2: 0x0140, 0x4b3: 0x014c, 0x4b4: 0x014f, 0x4b5: 0x00ec,
+	0x4b6: 0x0152, 0x4b7: 0x0155, 0x4b8: 0x041f, 0x4b9: 0x0158, 0x4ba: 0x015b, 0x4bb: 0x00b5,
+	0x4bc: 0x015e, 0x4bd: 0x0161, 0x4be: 0x0164, 0x4bf: 0x01d0,
+	// Block 0x13, offset 0x4c0
+	0x4c0: 0x8132, 0x4c1: 0x8132, 0x4c2: 0x812d, 0x4c3: 0x8132, 0x4c4: 0x8132, 0x4c5: 0x8132,
+	0x4c6: 0x8132, 0x4c7: 0x8132, 0x4c8: 0x8132, 0x4c9: 0x8132, 0x4ca: 0x812d, 0x4cb: 0x8132,
+	0x4cc: 0x8132, 0x4cd: 0x8135, 0x4ce: 0x812a, 0x4cf: 0x812d, 0x4d0: 0x8129, 0x4d1: 0x8132,
+	0x4d2: 0x8132, 0x4d3: 0x8132, 0x4d4: 0x8132, 0x4d5: 0x8132, 0x4d6: 0x8132, 0x4d7: 0x8132,
+	0x4d8: 0x8132, 0x4d9: 0x8132, 0x4da: 0x8132, 0x4db: 0x8132, 0x4dc: 0x8132, 0x4dd: 0x8132,
+	0x4de: 0x8132, 0x4df: 0x8132, 0x4e0: 0x8132, 0x4e1: 0x8132, 0x4e2: 0x8132, 0x4e3: 0x8132,
+	0x4e4: 0x8132, 0x4e5: 0x8132, 0x4e6: 0x8132, 0x4e7: 0x8132, 0x4e8: 0x8132, 0x4e9: 0x8132,
+	0x4ea: 0x8132, 0x4eb: 0x8132, 0x4ec: 0x8132, 0x4ed: 0x8132, 0x4ee: 0x8132, 0x4ef: 0x8132,
+	0x4f0: 0x8132, 0x4f1: 0x8132, 0x4f2: 0x8132, 0x4f3: 0x8132, 0x4f4: 0x8132, 0x4f5: 0x8132,
+	0x4f6: 0x8133, 0x4f7: 0x8131, 0x4f8: 0x8131, 0x4f9: 0x812d, 0x4fb: 0x8132,
+	0x4fc: 0x8134, 0x4fd: 0x812d, 0x4fe: 0x8132, 0x4ff: 0x812d,
+	// Block 0x14, offset 0x500
+	0x500: 0x2f97, 0x501: 0x32a3, 0x502: 0x2fa1, 0x503: 0x32ad, 0x504: 0x2fa6, 0x505: 0x32b2,
+	0x506: 0x2fab, 0x507: 0x32b7, 0x508: 0x38cc, 0x509: 0x3a5b, 0x50a: 0x2fc4, 0x50b: 0x32d0,
+	0x50c: 0x2fce, 0x50d: 0x32da, 0x50e: 0x2fdd, 0x50f: 0x32e9, 0x510: 0x2fd3, 0x511: 0x32df,
+	0x512: 0x2fd8, 0x513: 0x32e4, 0x514: 0x38ef, 0x515: 0x3a7e, 0x516: 0x38f6, 0x517: 0x3a85,
+	0x518: 0x3019, 0x519: 0x3325, 0x51a: 0x301e, 0x51b: 0x332a, 0x51c: 0x3904, 0x51d: 0x3a93,
+	0x51e: 0x3023, 0x51f: 0x332f, 0x520: 0x3032, 0x521: 0x333e, 0x522: 0x3050, 0x523: 0x335c,
+	0x524: 0x305f, 0x525: 0x336b, 0x526: 0x3055, 0x527: 0x3361, 0x528: 0x3064, 0x529: 0x3370,
+	0x52a: 0x3069, 0x52b: 0x3375, 0x52c: 0x30af, 0x52d: 0x33bb, 0x52e: 0x390b, 0x52f: 0x3a9a,
+	0x530: 0x30b9, 0x531: 0x33ca, 0x532: 0x30c3, 0x533: 0x33d4, 0x534: 0x30cd, 0x535: 0x33de,
+	0x536: 0x46c4, 0x537: 0x4755, 0x538: 0x3912, 0x539: 0x3aa1, 0x53a: 0x30e6, 0x53b: 0x33f7,
+	0x53c: 0x30e1, 0x53d: 0x33f2, 0x53e: 0x30eb, 0x53f: 0x33fc,
+	// Block 0x15, offset 0x540
+	0x540: 0x30f0, 0x541: 0x3401, 0x542: 0x30f5, 0x543: 0x3406, 0x544: 0x3109, 0x545: 0x341a,
+	0x546: 0x3113, 0x547: 0x3424, 0x548: 0x3122, 0x549: 0x3433, 0x54a: 0x311d, 0x54b: 0x342e,
+	0x54c: 0x3935, 0x54d: 0x3ac4, 0x54e: 0x3943, 0x54f: 0x3ad2, 0x550: 0x394a, 0x551: 0x3ad9,
+	0x552: 0x3951, 0x553: 0x3ae0, 0x554: 0x314f, 0x555: 0x3460, 0x556: 0x3154, 0x557: 0x3465,
+	0x558: 0x315e, 0x559: 0x346f, 0x55a: 0x46f1, 0x55b: 0x4782, 0x55c: 0x3997, 0x55d: 0x3b26,
+	0x55e: 0x3177, 0x55f: 0x3488, 0x560: 0x3181, 0x561: 0x3492, 0x562: 0x4700, 0x563: 0x4791,
+	0x564: 0x399e, 0x565: 0x3b2d, 0x566: 0x39a5, 0x567: 0x3b34, 0x568: 0x39ac, 0x569: 0x3b3b,
+	0x56a: 0x3190, 0x56b: 0x34a1, 0x56c: 0x319a, 0x56d: 0x34b0, 0x56e: 0x31ae, 0x56f: 0x34c4,
+	0x570: 0x31a9, 0x571: 0x34bf, 0x572: 0x31ea, 0x573: 0x3500, 0x574: 0x31f9, 0x575: 0x350f,
+	0x576: 0x31f4, 0x577: 0x350a, 0x578: 0x39b3, 0x579: 0x3b42, 0x57a: 0x39ba, 0x57b: 0x3b49,
+	0x57c: 0x31fe, 0x57d: 0x3514, 0x57e: 0x3203, 0x57f: 0x3519,
+	// Block 0x16, offset 0x580
+	0x580: 0x3208, 0x581: 0x351e, 0x582: 0x320d, 0x583: 0x3523, 0x584: 0x321c, 0x585: 0x3532,
+	0x586: 0x3217, 0x587: 0x352d, 0x588: 0x3221, 0x589: 0x353c, 0x58a: 0x3226, 0x58b: 0x3541,
+	0x58c: 0x322b, 0x58d: 0x3546, 0x58e: 0x3249, 0x58f: 0x3564, 0x590: 0x3262, 0x591: 0x3582,
+	0x592: 0x3271, 0x593: 0x3591, 0x594: 0x3276, 0x595: 0x3596, 0x596: 0x337a, 0x597: 0x34a6,
+	0x598: 0x3537, 0x599: 0x3573, 0x59a: 0x1be0, 0x59b: 0x42d7,
+	0x5a0: 0x46a1, 0x5a1: 0x4732, 0x5a2: 0x2f83, 0x5a3: 0x328f,
+	0x5a4: 0x3878, 0x5a5: 0x3a07, 0x5a6: 0x3871, 0x5a7: 0x3a00, 0x5a8: 0x3886, 0x5a9: 0x3a15,
+	0x5aa: 0x387f, 0x5ab: 0x3a0e, 0x5ac: 0x38be, 0x5ad: 0x3a4d, 0x5ae: 0x3894, 0x5af: 0x3a23,
+	0x5b0: 0x388d, 0x5b1: 0x3a1c, 0x5b2: 0x38a2, 0x5b3: 0x3a31, 0x5b4: 0x389b, 0x5b5: 0x3a2a,
+	0x5b6: 0x38c5, 0x5b7: 0x3a54, 0x5b8: 0x46b5, 0x5b9: 0x4746, 0x5ba: 0x3000, 0x5bb: 0x330c,
+	0x5bc: 0x2fec, 0x5bd: 0x32f8, 0x5be: 0x38da, 0x5bf: 0x3a69,
+	// Block 0x17, offset 0x5c0
+	0x5c0: 0x38d3, 0x5c1: 0x3a62, 0x5c2: 0x38e8, 0x5c3: 0x3a77, 0x5c4: 0x38e1, 0x5c5: 0x3a70,
+	0x5c6: 0x38fd, 0x5c7: 0x3a8c, 0x5c8: 0x3091, 0x5c9: 0x339d, 0x5ca: 0x30a5, 0x5cb: 0x33b1,
+	0x5cc: 0x46e7, 0x5cd: 0x4778, 0x5ce: 0x3136, 0x5cf: 0x3447, 0x5d0: 0x3920, 0x5d1: 0x3aaf,
+	0x5d2: 0x3919, 0x5d3: 0x3aa8, 0x5d4: 0x392e, 0x5d5: 0x3abd, 0x5d6: 0x3927, 0x5d7: 0x3ab6,
+	0x5d8: 0x3989, 0x5d9: 0x3b18, 0x5da: 0x396d, 0x5db: 0x3afc, 0x5dc: 0x3966, 0x5dd: 0x3af5,
+	0x5de: 0x397b, 0x5df: 0x3b0a, 0x5e0: 0x3974, 0x5e1: 0x3b03, 0x5e2: 0x3982, 0x5e3: 0x3b11,
+	0x5e4: 0x31e5, 0x5e5: 0x34fb, 0x5e6: 0x31c7, 0x5e7: 0x34dd, 0x5e8: 0x39e4, 0x5e9: 0x3b73,
+	0x5ea: 0x39dd, 0x5eb: 0x3b6c, 0x5ec: 0x39f2, 0x5ed: 0x3b81, 0x5ee: 0x39eb, 0x5ef: 0x3b7a,
+	0x5f0: 0x39f9, 0x5f1: 0x3b88, 0x5f2: 0x3230, 0x5f3: 0x354b, 0x5f4: 0x3258, 0x5f5: 0x3578,
+	0x5f6: 0x3253, 0x5f7: 0x356e, 0x5f8: 0x323f, 0x5f9: 0x355a,
+	// Block 0x18, offset 0x600
+	0x600: 0x4804, 0x601: 0x480a, 0x602: 0x491e, 0x603: 0x4936, 0x604: 0x4926, 0x605: 0x493e,
+	0x606: 0x492e, 0x607: 0x4946, 0x608: 0x47aa, 0x609: 0x47b0, 0x60a: 0x488e, 0x60b: 0x48a6,
+	0x60c: 0x4896, 0x60d: 0x48ae, 0x60e: 0x489e, 0x60f: 0x48b6, 0x610: 0x4816, 0x611: 0x481c,
+	0x612: 0x3db8, 0x613: 0x3dc8, 0x614: 0x3dc0, 0x615: 0x3dd0,
+	0x618: 0x47b6, 0x619: 0x47bc, 0x61a: 0x3ce8, 0x61b: 0x3cf8, 0x61c: 0x3cf0, 0x61d: 0x3d00,
+	0x620: 0x482e, 0x621: 0x4834, 0x622: 0x494e, 0x623: 0x4966,
+	0x624: 0x4956, 0x625: 0x496e, 0x626: 0x495e, 0x627: 0x4976, 0x628: 0x47c2, 0x629: 0x47c8,
+	0x62a: 0x48be, 0x62b: 0x48d6, 0x62c: 0x48c6, 0x62d: 0x48de, 0x62e: 0x48ce, 0x62f: 0x48e6,
+	0x630: 0x4846, 0x631: 0x484c, 0x632: 0x3e18, 0x633: 0x3e30, 0x634: 0x3e20, 0x635: 0x3e38,
+	0x636: 0x3e28, 0x637: 0x3e40, 0x638: 0x47ce, 0x639: 0x47d4, 0x63a: 0x3d18, 0x63b: 0x3d30,
+	0x63c: 0x3d20, 0x63d: 0x3d38, 0x63e: 0x3d28, 0x63f: 0x3d40,
+	// Block 0x19, offset 0x640
+	0x640: 0x4852, 0x641: 0x4858, 0x642: 0x3e48, 0x643: 0x3e58, 0x644: 0x3e50, 0x645: 0x3e60,
+	0x648: 0x47da, 0x649: 0x47e0, 0x64a: 0x3d48, 0x64b: 0x3d58,
+	0x64c: 0x3d50, 0x64d: 0x3d60, 0x650: 0x4864, 0x651: 0x486a,
+	0x652: 0x3e80, 0x653: 0x3e98, 0x654: 0x3e88, 0x655: 0x3ea0, 0x656: 0x3e90, 0x657: 0x3ea8,
+	0x659: 0x47e6, 0x65b: 0x3d68, 0x65d: 0x3d70,
+	0x65f: 0x3d78, 0x660: 0x487c, 0x661: 0x4882, 0x662: 0x497e, 0x663: 0x4996,
+	0x664: 0x4986, 0x665: 0x499e, 0x666: 0x498e, 0x667: 0x49a6, 0x668: 0x47ec, 0x669: 0x47f2,
+	0x66a: 0x48ee, 0x66b: 0x4906, 0x66c: 0x48f6, 0x66d: 0x490e, 0x66e: 0x48fe, 0x66f: 0x4916,
+	0x670: 0x47f8, 0x671: 0x431e, 0x672: 0x3691, 0x673: 0x4324, 0x674: 0x4822, 0x675: 0x432a,
+	0x676: 0x36a3, 0x677: 0x4330, 0x678: 0x36c1, 0x679: 0x4336, 0x67a: 0x36d9, 0x67b: 0x433c,
+	0x67c: 0x4870, 0x67d: 0x4342,
+	// Block 0x1a, offset 0x680
+	0x680: 0x3da0, 0x681: 0x3da8, 0x682: 0x4184, 0x683: 0x41a2, 0x684: 0x418e, 0x685: 0x41ac,
+	0x686: 0x4198, 0x687: 0x41b6, 0x688: 0x3cd8, 0x689: 0x3ce0, 0x68a: 0x40d0, 0x68b: 0x40ee,
+	0x68c: 0x40da, 0x68d: 0x40f8, 0x68e: 0x40e4, 0x68f: 0x4102, 0x690: 0x3de8, 0x691: 0x3df0,
+	0x692: 0x41c0, 0x693: 0x41de, 0x694: 0x41ca, 0x695: 0x41e8, 0x696: 0x41d4, 0x697: 0x41f2,
+	0x698: 0x3d08, 0x699: 0x3d10, 0x69a: 0x410c, 0x69b: 0x412a, 0x69c: 0x4116, 0x69d: 0x4134,
+	0x69e: 0x4120, 0x69f: 0x413e, 0x6a0: 0x3ec0, 0x6a1: 0x3ec8, 0x6a2: 0x41fc, 0x6a3: 0x421a,
+	0x6a4: 0x4206, 0x6a5: 0x4224, 0x6a6: 0x4210, 0x6a7: 0x422e, 0x6a8: 0x3d80, 0x6a9: 0x3d88,
+	0x6aa: 0x4148, 0x6ab: 0x4166, 0x6ac: 0x4152, 0x6ad: 0x4170, 0x6ae: 0x415c, 0x6af: 0x417a,
+	0x6b0: 0x3685, 0x6b1: 0x367f, 0x6b2: 0x3d90, 0x6b3: 0x368b, 0x6b4: 0x3d98,
+	0x6b6: 0x4810, 0x6b7: 0x3db0, 0x6b8: 0x35f5, 0x6b9: 0x35ef, 0x6ba: 0x35e3, 0x6bb: 0x42ee,
+	0x6bc: 0x35fb, 0x6bd: 0x4287, 0x6be: 0x01d3, 0x6bf: 0x4287,
+	// Block 0x1b, offset 0x6c0
+	0x6c0: 0x42a0, 0x6c1: 0x4482, 0x6c2: 0x3dd8, 0x6c3: 0x369d, 0x6c4: 0x3de0,
+	0x6c6: 0x483a, 0x6c7: 0x3df8, 0x6c8: 0x3601, 0x6c9: 0x42f4, 0x6ca: 0x360d, 0x6cb: 0x42fa,
+	0x6cc: 0x3619, 0x6cd: 0x4489, 0x6ce: 0x4490, 0x6cf: 0x4497, 0x6d0: 0x36b5, 0x6d1: 0x36af,
+	0x6d2: 0x3e00, 0x6d3: 0x44e4, 0x6d6: 0x36bb, 0x6d7: 0x3e10,
+	0x6d8: 0x3631, 0x6d9: 0x362b, 0x6da: 0x361f, 0x6db: 0x4300, 0x6dd: 0x449e,
+	0x6de: 0x44a5, 0x6df: 0x44ac, 0x6e0: 0x36eb, 0x6e1: 0x36e5, 0x6e2: 0x3e68, 0x6e3: 0x44ec,
+	0x6e4: 0x36cd, 0x6e5: 0x36d3, 0x6e6: 0x36f1, 0x6e7: 0x3e78, 0x6e8: 0x3661, 0x6e9: 0x365b,
+	0x6ea: 0x364f, 0x6eb: 0x430c, 0x6ec: 0x3649, 0x6ed: 0x4474, 0x6ee: 0x447b, 0x6ef: 0x0081,
+	0x6f2: 0x3eb0, 0x6f3: 0x36f7, 0x6f4: 0x3eb8,
+	0x6f6: 0x4888, 0x6f7: 0x3ed0, 0x6f8: 0x363d, 0x6f9: 0x4306, 0x6fa: 0x366d, 0x6fb: 0x4318,
+	0x6fc: 0x3679, 0x6fd: 0x425a, 0x6fe: 0x428c,
+	// Block 0x1c, offset 0x700
+	0x700: 0x1bd8, 0x701: 0x1bdc, 0x702: 0x0047, 0x703: 0x1c54, 0x705: 0x1be8,
+	0x706: 0x1bec, 0x707: 0x00e9, 0x709: 0x1c58, 0x70a: 0x008f, 0x70b: 0x0051,
+	0x70c: 0x0051, 0x70d: 0x0051, 0x70e: 0x0091, 0x70f: 0x00da, 0x710: 0x0053, 0x711: 0x0053,
+	0x712: 0x0059, 0x713: 0x0099, 0x715: 0x005d, 0x716: 0x198d,
+	0x719: 0x0061, 0x71a: 0x0063, 0x71b: 0x0065, 0x71c: 0x0065, 0x71d: 0x0065,
+	0x720: 0x199f, 0x721: 0x1bc8, 0x722: 0x19a8,
+	0x724: 0x0075, 0x726: 0x01b8, 0x728: 0x0075,
+	0x72a: 0x0057, 0x72b: 0x42d2, 0x72c: 0x0045, 0x72d: 0x0047, 0x72f: 0x008b,
+	0x730: 0x004b, 0x731: 0x004d, 0x733: 0x005b, 0x734: 0x009f, 0x735: 0x0215,
+	0x736: 0x0218, 0x737: 0x021b, 0x738: 0x021e, 0x739: 0x0093, 0x73b: 0x1b98,
+	0x73c: 0x01e8, 0x73d: 0x01c1, 0x73e: 0x0179, 0x73f: 0x01a0,
+	// Block 0x1d, offset 0x740
+	0x740: 0x0463, 0x745: 0x0049,
+	0x746: 0x0089, 0x747: 0x008b, 0x748: 0x0093, 0x749: 0x0095,
+	0x750: 0x222e, 0x751: 0x223a,
+	0x752: 0x22ee, 0x753: 0x2216, 0x754: 0x229a, 0x755: 0x2222, 0x756: 0x22a0, 0x757: 0x22b8,
+	0x758: 0x22c4, 0x759: 0x2228, 0x75a: 0x22ca, 0x75b: 0x2234, 0x75c: 0x22be, 0x75d: 0x22d0,
+	0x75e: 0x22d6, 0x75f: 0x1cbc, 0x760: 0x0053, 0x761: 0x195a, 0x762: 0x1ba4, 0x763: 0x1963,
+	0x764: 0x006d, 0x765: 0x19ab, 0x766: 0x1bd0, 0x767: 0x1d48, 0x768: 0x1966, 0x769: 0x0071,
+	0x76a: 0x19b7, 0x76b: 0x1bd4, 0x76c: 0x0059, 0x76d: 0x0047, 0x76e: 0x0049, 0x76f: 0x005b,
+	0x770: 0x0093, 0x771: 0x19e4, 0x772: 0x1c18, 0x773: 0x19ed, 0x774: 0x00ad, 0x775: 0x1a62,
+	0x776: 0x1c4c, 0x777: 0x1d5c, 0x778: 0x19f0, 0x779: 0x00b1, 0x77a: 0x1a65, 0x77b: 0x1c50,
+	0x77c: 0x0099, 0x77d: 0x0087, 0x77e: 0x0089, 0x77f: 0x009b,
+	// Block 0x1e, offset 0x780
+	0x781: 0x3c06, 0x783: 0xa000, 0x784: 0x3c0d, 0x785: 0xa000,
+	0x787: 0x3c14, 0x788: 0xa000, 0x789: 0x3c1b,
+	0x78d: 0xa000,
+	0x7a0: 0x2f65, 0x7a1: 0xa000, 0x7a2: 0x3c29,
+	0x7a4: 0xa000, 0x7a5: 0xa000,
+	0x7ad: 0x3c22, 0x7ae: 0x2f60, 0x7af: 0x2f6a,
+	0x7b0: 0x3c30, 0x7b1: 0x3c37, 0x7b2: 0xa000, 0x7b3: 0xa000, 0x7b4: 0x3c3e, 0x7b5: 0x3c45,
+	0x7b6: 0xa000, 0x7b7: 0xa000, 0x7b8: 0x3c4c, 0x7b9: 0x3c53, 0x7ba: 0xa000, 0x7bb: 0xa000,
+	0x7bc: 0xa000, 0x7bd: 0xa000,
+	// Block 0x1f, offset 0x7c0
+	0x7c0: 0x3c5a, 0x7c1: 0x3c61, 0x7c2: 0xa000, 0x7c3: 0xa000, 0x7c4: 0x3c76, 0x7c5: 0x3c7d,
+	0x7c6: 0xa000, 0x7c7: 0xa000, 0x7c8: 0x3c84, 0x7c9: 0x3c8b,
+	0x7d1: 0xa000,
+	0x7d2: 0xa000,
+	0x7e2: 0xa000,
+	0x7e8: 0xa000, 0x7e9: 0xa000,
+	0x7eb: 0xa000, 0x7ec: 0x3ca0, 0x7ed: 0x3ca7, 0x7ee: 0x3cae, 0x7ef: 0x3cb5,
+	0x7f2: 0xa000, 0x7f3: 0xa000, 0x7f4: 0xa000, 0x7f5: 0xa000,
+	// Block 0x20, offset 0x800
+	0x820: 0x0023, 0x821: 0x0025, 0x822: 0x0027, 0x823: 0x0029,
+	0x824: 0x002b, 0x825: 0x002d, 0x826: 0x002f, 0x827: 0x0031, 0x828: 0x0033, 0x829: 0x1882,
+	0x82a: 0x1885, 0x82b: 0x1888, 0x82c: 0x188b, 0x82d: 0x188e, 0x82e: 0x1891, 0x82f: 0x1894,
+	0x830: 0x1897, 0x831: 0x189a, 0x832: 0x189d, 0x833: 0x18a6, 0x834: 0x1a68, 0x835: 0x1a6c,
+	0x836: 0x1a70, 0x837: 0x1a74, 0x838: 0x1a78, 0x839: 0x1a7c, 0x83a: 0x1a80, 0x83b: 0x1a84,
+	0x83c: 0x1a88, 0x83d: 0x1c80, 0x83e: 0x1c85, 0x83f: 0x1c8a,
+	// Block 0x21, offset 0x840
+	0x840: 0x1c8f, 0x841: 0x1c94, 0x842: 0x1c99, 0x843: 0x1c9e, 0x844: 0x1ca3, 0x845: 0x1ca8,
+	0x846: 0x1cad, 0x847: 0x1cb2, 0x848: 0x187f, 0x849: 0x18a3, 0x84a: 0x18c7, 0x84b: 0x18eb,
+	0x84c: 0x190f, 0x84d: 0x1918, 0x84e: 0x191e, 0x84f: 0x1924, 0x850: 0x192a, 0x851: 0x1b60,
+	0x852: 0x1b64, 0x853: 0x1b68, 0x854: 0x1b6c, 0x855: 0x1b70, 0x856: 0x1b74, 0x857: 0x1b78,
+	0x858: 0x1b7c, 0x859: 0x1b80, 0x85a: 0x1b84, 0x85b: 0x1b88, 0x85c: 0x1af4, 0x85d: 0x1af8,
+	0x85e: 0x1afc, 0x85f: 0x1b00, 0x860: 0x1b04, 0x861: 0x1b08, 0x862: 0x1b0c, 0x863: 0x1b10,
+	0x864: 0x1b14, 0x865: 0x1b18, 0x866: 0x1b1c, 0x867: 0x1b20, 0x868: 0x1b24, 0x869: 0x1b28,
+	0x86a: 0x1b2c, 0x86b: 0x1b30, 0x86c: 0x1b34, 0x86d: 0x1b38, 0x86e: 0x1b3c, 0x86f: 0x1b40,
+	0x870: 0x1b44, 0x871: 0x1b48, 0x872: 0x1b4c, 0x873: 0x1b50, 0x874: 0x1b54, 0x875: 0x1b58,
+	0x876: 0x0043, 0x877: 0x0045, 0x878: 0x0047, 0x879: 0x0049, 0x87a: 0x004b, 0x87b: 0x004d,
+	0x87c: 0x004f, 0x87d: 0x0051, 0x87e: 0x0053, 0x87f: 0x0055,
+	// Block 0x22, offset 0x880
+	0x880: 0x06bf, 0x881: 0x06e3, 0x882: 0x06ef, 0x883: 0x06ff, 0x884: 0x0707, 0x885: 0x0713,
+	0x886: 0x071b, 0x887: 0x0723, 0x888: 0x072f, 0x889: 0x0783, 0x88a: 0x079b, 0x88b: 0x07ab,
+	0x88c: 0x07bb, 0x88d: 0x07cb, 0x88e: 0x07db, 0x88f: 0x07fb, 0x890: 0x07ff, 0x891: 0x0803,
+	0x892: 0x0837, 0x893: 0x085f, 0x894: 0x086f, 0x895: 0x0877, 0x896: 0x087b, 0x897: 0x0887,
+	0x898: 0x08a3, 0x899: 0x08a7, 0x89a: 0x08bf, 0x89b: 0x08c3, 0x89c: 0x08cb, 0x89d: 0x08db,
+	0x89e: 0x0977, 0x89f: 0x098b, 0x8a0: 0x09cb, 0x8a1: 0x09df, 0x8a2: 0x09e7, 0x8a3: 0x09eb,
+	0x8a4: 0x09fb, 0x8a5: 0x0a17, 0x8a6: 0x0a43, 0x8a7: 0x0a4f, 0x8a8: 0x0a6f, 0x8a9: 0x0a7b,
+	0x8aa: 0x0a7f, 0x8ab: 0x0a83, 0x8ac: 0x0a9b, 0x8ad: 0x0a9f, 0x8ae: 0x0acb, 0x8af: 0x0ad7,
+	0x8b0: 0x0adf, 0x8b1: 0x0ae7, 0x8b2: 0x0af7, 0x8b3: 0x0aff, 0x8b4: 0x0b07, 0x8b5: 0x0b33,
+	0x8b6: 0x0b37, 0x8b7: 0x0b3f, 0x8b8: 0x0b43, 0x8b9: 0x0b4b, 0x8ba: 0x0b53, 0x8bb: 0x0b63,
+	0x8bc: 0x0b7f, 0x8bd: 0x0bf7, 0x8be: 0x0c0b, 0x8bf: 0x0c0f,
+	// Block 0x23, offset 0x8c0
+	0x8c0: 0x0c8f, 0x8c1: 0x0c93, 0x8c2: 0x0ca7, 0x8c3: 0x0cab, 0x8c4: 0x0cb3, 0x8c5: 0x0cbb,
+	0x8c6: 0x0cc3, 0x8c7: 0x0ccf, 0x8c8: 0x0cf7, 0x8c9: 0x0d07, 0x8ca: 0x0d1b, 0x8cb: 0x0d8b,
+	0x8cc: 0x0d97, 0x8cd: 0x0da7, 0x8ce: 0x0db3, 0x8cf: 0x0dbf, 0x8d0: 0x0dc7, 0x8d1: 0x0dcb,
+	0x8d2: 0x0dcf, 0x8d3: 0x0dd3, 0x8d4: 0x0dd7, 0x8d5: 0x0e8f, 0x8d6: 0x0ed7, 0x8d7: 0x0ee3,
+	0x8d8: 0x0ee7, 0x8d9: 0x0eeb, 0x8da: 0x0eef, 0x8db: 0x0ef7, 0x8dc: 0x0efb, 0x8dd: 0x0f0f,
+	0x8de: 0x0f2b, 0x8df: 0x0f33, 0x8e0: 0x0f73, 0x8e1: 0x0f77, 0x8e2: 0x0f7f, 0x8e3: 0x0f83,
+	0x8e4: 0x0f8b, 0x8e5: 0x0f8f, 0x8e6: 0x0fb3, 0x8e7: 0x0fb7, 0x8e8: 0x0fd3, 0x8e9: 0x0fd7,
+	0x8ea: 0x0fdb, 0x8eb: 0x0fdf, 0x8ec: 0x0ff3, 0x8ed: 0x1017, 0x8ee: 0x101b, 0x8ef: 0x101f,
+	0x8f0: 0x1043, 0x8f1: 0x1083, 0x8f2: 0x1087, 0x8f3: 0x10a7, 0x8f4: 0x10b7, 0x8f5: 0x10bf,
+	0x8f6: 0x10df, 0x8f7: 0x1103, 0x8f8: 0x1147, 0x8f9: 0x114f, 0x8fa: 0x1163, 0x8fb: 0x116f,
+	0x8fc: 0x1177, 0x8fd: 0x117f, 0x8fe: 0x1183, 0x8ff: 0x1187,
+	// Block 0x24, offset 0x900
+	0x900: 0x119f, 0x901: 0x11a3, 0x902: 0x11bf, 0x903: 0x11c7, 0x904: 0x11cf, 0x905: 0x11d3,
+	0x906: 0x11df, 0x907: 0x11e7, 0x908: 0x11eb, 0x909: 0x11ef, 0x90a: 0x11f7, 0x90b: 0x11fb,
+	0x90c: 0x129b, 0x90d: 0x12af, 0x90e: 0x12e3, 0x90f: 0x12e7, 0x910: 0x12ef, 0x911: 0x131b,
+	0x912: 0x1323, 0x913: 0x132b, 0x914: 0x1333, 0x915: 0x136f, 0x916: 0x1373, 0x917: 0x137b,
+	0x918: 0x137f, 0x919: 0x1383, 0x91a: 0x13af, 0x91b: 0x13b3, 0x91c: 0x13bb, 0x91d: 0x13cf,
+	0x91e: 0x13d3, 0x91f: 0x13ef, 0x920: 0x13f7, 0x921: 0x13fb, 0x922: 0x141f, 0x923: 0x143f,
+	0x924: 0x1453, 0x925: 0x1457, 0x926: 0x145f, 0x927: 0x148b, 0x928: 0x148f, 0x929: 0x149f,
+	0x92a: 0x14c3, 0x92b: 0x14cf, 0x92c: 0x14df, 0x92d: 0x14f7, 0x92e: 0x14ff, 0x92f: 0x1503,
+	0x930: 0x1507, 0x931: 0x150b, 0x932: 0x1517, 0x933: 0x151b, 0x934: 0x1523, 0x935: 0x153f,
+	0x936: 0x1543, 0x937: 0x1547, 0x938: 0x155f, 0x939: 0x1563, 0x93a: 0x156b, 0x93b: 0x157f,
+	0x93c: 0x1583, 0x93d: 0x1587, 0x93e: 0x158f, 0x93f: 0x1593,
+	// Block 0x25, offset 0x940
+	0x946: 0xa000, 0x94b: 0xa000,
+	0x94c: 0x3f08, 0x94d: 0xa000, 0x94e: 0x3f10, 0x94f: 0xa000, 0x950: 0x3f18, 0x951: 0xa000,
+	0x952: 0x3f20, 0x953: 0xa000, 0x954: 0x3f28, 0x955: 0xa000, 0x956: 0x3f30, 0x957: 0xa000,
+	0x958: 0x3f38, 0x959: 0xa000, 0x95a: 0x3f40, 0x95b: 0xa000, 0x95c: 0x3f48, 0x95d: 0xa000,
+	0x95e: 0x3f50, 0x95f: 0xa000, 0x960: 0x3f58, 0x961: 0xa000, 0x962: 0x3f60,
+	0x964: 0xa000, 0x965: 0x3f68, 0x966: 0xa000, 0x967: 0x3f70, 0x968: 0xa000, 0x969: 0x3f78,
+	0x96f: 0xa000,
+	0x970: 0x3f80, 0x971: 0x3f88, 0x972: 0xa000, 0x973: 0x3f90, 0x974: 0x3f98, 0x975: 0xa000,
+	0x976: 0x3fa0, 0x977: 0x3fa8, 0x978: 0xa000, 0x979: 0x3fb0, 0x97a: 0x3fb8, 0x97b: 0xa000,
+	0x97c: 0x3fc0, 0x97d: 0x3fc8,
+	// Block 0x26, offset 0x980
+	0x994: 0x3f00,
+	0x999: 0x9903, 0x99a: 0x9903, 0x99b: 0x42dc, 0x99c: 0x42e2, 0x99d: 0xa000,
+	0x99e: 0x3fd0, 0x99f: 0x26b4,
+	0x9a6: 0xa000,
+	0x9ab: 0xa000, 0x9ac: 0x3fe0, 0x9ad: 0xa000, 0x9ae: 0x3fe8, 0x9af: 0xa000,
+	0x9b0: 0x3ff0, 0x9b1: 0xa000, 0x9b2: 0x3ff8, 0x9b3: 0xa000, 0x9b4: 0x4000, 0x9b5: 0xa000,
+	0x9b6: 0x4008, 0x9b7: 0xa000, 0x9b8: 0x4010, 0x9b9: 0xa000, 0x9ba: 0x4018, 0x9bb: 0xa000,
+	0x9bc: 0x4020, 0x9bd: 0xa000, 0x9be: 0x4028, 0x9bf: 0xa000,
+	// Block 0x27, offset 0x9c0
+	0x9c0: 0x4030, 0x9c1: 0xa000, 0x9c2: 0x4038, 0x9c4: 0xa000, 0x9c5: 0x4040,
+	0x9c6: 0xa000, 0x9c7: 0x4048, 0x9c8: 0xa000, 0x9c9: 0x4050,
+	0x9cf: 0xa000, 0x9d0: 0x4058, 0x9d1: 0x4060,
+	0x9d2: 0xa000, 0x9d3: 0x4068, 0x9d4: 0x4070, 0x9d5: 0xa000, 0x9d6: 0x4078, 0x9d7: 0x4080,
+	0x9d8: 0xa000, 0x9d9: 0x4088, 0x9da: 0x4090, 0x9db: 0xa000, 0x9dc: 0x4098, 0x9dd: 0x40a0,
+	0x9ef: 0xa000,
+	0x9f0: 0xa000, 0x9f1: 0xa000, 0x9f2: 0xa000, 0x9f4: 0x3fd8,
+	0x9f7: 0x40a8, 0x9f8: 0x40b0, 0x9f9: 0x40b8, 0x9fa: 0x40c0,
+	0x9fd: 0xa000, 0x9fe: 0x40c8, 0x9ff: 0x26c9,
+	// Block 0x28, offset 0xa00
+	0xa00: 0x0367, 0xa01: 0x032b, 0xa02: 0x032f, 0xa03: 0x0333, 0xa04: 0x037b, 0xa05: 0x0337,
+	0xa06: 0x033b, 0xa07: 0x033f, 0xa08: 0x0343, 0xa09: 0x0347, 0xa0a: 0x034b, 0xa0b: 0x034f,
+	0xa0c: 0x0353, 0xa0d: 0x0357, 0xa0e: 0x035b, 0xa0f: 0x49bd, 0xa10: 0x49c3, 0xa11: 0x49c9,
+	0xa12: 0x49cf, 0xa13: 0x49d5, 0xa14: 0x49db, 0xa15: 0x49e1, 0xa16: 0x49e7, 0xa17: 0x49ed,
+	0xa18: 0x49f3, 0xa19: 0x49f9, 0xa1a: 0x49ff, 0xa1b: 0x4a05, 0xa1c: 0x4a0b, 0xa1d: 0x4a11,
+	0xa1e: 0x4a17, 0xa1f: 0x4a1d, 0xa20: 0x4a23, 0xa21: 0x4a29, 0xa22: 0x4a2f, 0xa23: 0x4a35,
+	0xa24: 0x03c3, 0xa25: 0x035f, 0xa26: 0x0363, 0xa27: 0x03e7, 0xa28: 0x03eb, 0xa29: 0x03ef,
+	0xa2a: 0x03f3, 0xa2b: 0x03f7, 0xa2c: 0x03fb, 0xa2d: 0x03ff, 0xa2e: 0x036b, 0xa2f: 0x0403,
+	0xa30: 0x0407, 0xa31: 0x036f, 0xa32: 0x0373, 0xa33: 0x0377, 0xa34: 0x037f, 0xa35: 0x0383,
+	0xa36: 0x0387, 0xa37: 0x038b, 0xa38: 0x038f, 0xa39: 0x0393, 0xa3a: 0x0397, 0xa3b: 0x039b,
+	0xa3c: 0x039f, 0xa3d: 0x03a3, 0xa3e: 0x03a7, 0xa3f: 0x03ab,
+	// Block 0x29, offset 0xa40
+	0xa40: 0x03af, 0xa41: 0x03b3, 0xa42: 0x040b, 0xa43: 0x040f, 0xa44: 0x03b7, 0xa45: 0x03bb,
+	0xa46: 0x03bf, 0xa47: 0x03c7, 0xa48: 0x03cb, 0xa49: 0x03cf, 0xa4a: 0x03d3, 0xa4b: 0x03d7,
+	0xa4c: 0x03db, 0xa4d: 0x03df, 0xa4e: 0x03e3,
+	0xa52: 0x06bf, 0xa53: 0x071b, 0xa54: 0x06cb, 0xa55: 0x097b, 0xa56: 0x06cf, 0xa57: 0x06e7,
+	0xa58: 0x06d3, 0xa59: 0x0f93, 0xa5a: 0x0707, 0xa5b: 0x06db, 0xa5c: 0x06c3, 0xa5d: 0x09ff,
+	0xa5e: 0x098f, 0xa5f: 0x072f,
+	// Block 0x2a, offset 0xa80
+	0xa80: 0x2054, 0xa81: 0x205a, 0xa82: 0x2060, 0xa83: 0x2066, 0xa84: 0x206c, 0xa85: 0x2072,
+	0xa86: 0x2078, 0xa87: 0x207e, 0xa88: 0x2084, 0xa89: 0x208a, 0xa8a: 0x2090, 0xa8b: 0x2096,
+	0xa8c: 0x209c, 0xa8d: 0x20a2, 0xa8e: 0x2726, 0xa8f: 0x272f, 0xa90: 0x2738, 0xa91: 0x2741,
+	0xa92: 0x274a, 0xa93: 0x2753, 0xa94: 0x275c, 0xa95: 0x2765, 0xa96: 0x276e, 0xa97: 0x2780,
+	0xa98: 0x2789, 0xa99: 0x2792, 0xa9a: 0x279b, 0xa9b: 0x27a4, 0xa9c: 0x2777, 0xa9d: 0x2bac,
+	0xa9e: 0x2aed, 0xaa0: 0x20a8, 0xaa1: 0x20c0, 0xaa2: 0x20b4, 0xaa3: 0x2108,
+	0xaa4: 0x20c6, 0xaa5: 0x20e4, 0xaa6: 0x20ae, 0xaa7: 0x20de, 0xaa8: 0x20ba, 0xaa9: 0x20f0,
+	0xaaa: 0x2120, 0xaab: 0x213e, 0xaac: 0x2138, 0xaad: 0x212c, 0xaae: 0x217a, 0xaaf: 0x210e,
+	0xab0: 0x211a, 0xab1: 0x2132, 0xab2: 0x2126, 0xab3: 0x2150, 0xab4: 0x20fc, 0xab5: 0x2144,
+	0xab6: 0x216e, 0xab7: 0x2156, 0xab8: 0x20ea, 0xab9: 0x20cc, 0xaba: 0x2102, 0xabb: 0x2114,
+	0xabc: 0x214a, 0xabd: 0x20d2, 0xabe: 0x2174, 0xabf: 0x20f6,
+	// Block 0x2b, offset 0xac0
+	0xac0: 0x215c, 0xac1: 0x20d8, 0xac2: 0x2162, 0xac3: 0x2168, 0xac4: 0x092f, 0xac5: 0x0b03,
+	0xac6: 0x0ca7, 0xac7: 0x10c7,
+	0xad0: 0x1bc4, 0xad1: 0x18a9,
+	0xad2: 0x18ac, 0xad3: 0x18af, 0xad4: 0x18b2, 0xad5: 0x18b5, 0xad6: 0x18b8, 0xad7: 0x18bb,
+	0xad8: 0x18be, 0xad9: 0x18c1, 0xada: 0x18ca, 0xadb: 0x18cd, 0xadc: 0x18d0, 0xadd: 0x18d3,
+	0xade: 0x18d6, 0xadf: 0x18d9, 0xae0: 0x0313, 0xae1: 0x031b, 0xae2: 0x031f, 0xae3: 0x0327,
+	0xae4: 0x032b, 0xae5: 0x032f, 0xae6: 0x0337, 0xae7: 0x033f, 0xae8: 0x0343, 0xae9: 0x034b,
+	0xaea: 0x034f, 0xaeb: 0x0353, 0xaec: 0x0357, 0xaed: 0x035b, 0xaee: 0x2e18, 0xaef: 0x2e20,
+	0xaf0: 0x2e28, 0xaf1: 0x2e30, 0xaf2: 0x2e38, 0xaf3: 0x2e40, 0xaf4: 0x2e48, 0xaf5: 0x2e50,
+	0xaf6: 0x2e60, 0xaf7: 0x2e68, 0xaf8: 0x2e70, 0xaf9: 0x2e78, 0xafa: 0x2e80, 0xafb: 0x2e88,
+	0xafc: 0x2ed3, 0xafd: 0x2e9b, 0xafe: 0x2e58,
+	// Block 0x2c, offset 0xb00
+	0xb00: 0x06bf, 0xb01: 0x071b, 0xb02: 0x06cb, 0xb03: 0x097b, 0xb04: 0x071f, 0xb05: 0x07af,
+	0xb06: 0x06c7, 0xb07: 0x07ab, 0xb08: 0x070b, 0xb09: 0x0887, 0xb0a: 0x0d07, 0xb0b: 0x0e8f,
+	0xb0c: 0x0dd7, 0xb0d: 0x0d1b, 0xb0e: 0x145f, 0xb0f: 0x098b, 0xb10: 0x0ccf, 0xb11: 0x0d4b,
+	0xb12: 0x0d0b, 0xb13: 0x104b, 0xb14: 0x08fb, 0xb15: 0x0f03, 0xb16: 0x1387, 0xb17: 0x105f,
+	0xb18: 0x0843, 0xb19: 0x108f, 0xb1a: 0x0f9b, 0xb1b: 0x0a17, 0xb1c: 0x140f, 0xb1d: 0x077f,
+	0xb1e: 0x08ab, 0xb1f: 0x0df7, 0xb20: 0x1527, 0xb21: 0x0743, 0xb22: 0x07d3, 0xb23: 0x0d9b,
+	0xb24: 0x06cf, 0xb25: 0x06e7, 0xb26: 0x06d3, 0xb27: 0x0adb, 0xb28: 0x08ef, 0xb29: 0x087f,
+	0xb2a: 0x0a57, 0xb2b: 0x0a4b, 0xb2c: 0x0feb, 0xb2d: 0x073f, 0xb2e: 0x139b, 0xb2f: 0x089b,
+	0xb30: 0x09f3, 0xb31: 0x18dc, 0xb32: 0x18df, 0xb33: 0x18e2, 0xb34: 0x18e5, 0xb35: 0x18ee,
+	0xb36: 0x18f1, 0xb37: 0x18f4, 0xb38: 0x18f7, 0xb39: 0x18fa, 0xb3a: 0x18fd, 0xb3b: 0x1900,
+	0xb3c: 0x1903, 0xb3d: 0x1906, 0xb3e: 0x1909, 0xb3f: 0x1912,
+	// Block 0x2d, offset 0xb40
+	0xb40: 0x1cc6, 0xb41: 0x1cd5, 0xb42: 0x1ce4, 0xb43: 0x1cf3, 0xb44: 0x1d02, 0xb45: 0x1d11,
+	0xb46: 0x1d20, 0xb47: 0x1d2f, 0xb48: 0x1d3e, 0xb49: 0x218c, 0xb4a: 0x219e, 0xb4b: 0x21b0,
+	0xb4c: 0x1954, 0xb4d: 0x1c04, 0xb4e: 0x19d2, 0xb4f: 0x1ba8, 0xb50: 0x04cb, 0xb51: 0x04d3,
+	0xb52: 0x04db, 0xb53: 0x04e3, 0xb54: 0x04eb, 0xb55: 0x04ef, 0xb56: 0x04f3, 0xb57: 0x04f7,
+	0xb58: 0x04fb, 0xb59: 0x04ff, 0xb5a: 0x0503, 0xb5b: 0x0507, 0xb5c: 0x050b, 0xb5d: 0x050f,
+	0xb5e: 0x0513, 0xb5f: 0x0517, 0xb60: 0x051b, 0xb61: 0x0523, 0xb62: 0x0527, 0xb63: 0x052b,
+	0xb64: 0x052f, 0xb65: 0x0533, 0xb66: 0x0537, 0xb67: 0x053b, 0xb68: 0x053f, 0xb69: 0x0543,
+	0xb6a: 0x0547, 0xb6b: 0x054b, 0xb6c: 0x054f, 0xb6d: 0x0553, 0xb6e: 0x0557, 0xb6f: 0x055b,
+	0xb70: 0x055f, 0xb71: 0x0563, 0xb72: 0x0567, 0xb73: 0x056f, 0xb74: 0x0577, 0xb75: 0x057f,
+	0xb76: 0x0583, 0xb77: 0x0587, 0xb78: 0x058b, 0xb79: 0x058f, 0xb7a: 0x0593, 0xb7b: 0x0597,
+	0xb7c: 0x059b, 0xb7d: 0x059f, 0xb7e: 0x05a3,
+	// Block 0x2e, offset 0xb80
+	0xb80: 0x2b0c, 0xb81: 0x29a8, 0xb82: 0x2b1c, 0xb83: 0x2880, 0xb84: 0x2ee4, 0xb85: 0x288a,
+	0xb86: 0x2894, 0xb87: 0x2f28, 0xb88: 0x29b5, 0xb89: 0x289e, 0xb8a: 0x28a8, 0xb8b: 0x28b2,
+	0xb8c: 0x29dc, 0xb8d: 0x29e9, 0xb8e: 0x29c2, 0xb8f: 0x29cf, 0xb90: 0x2ea9, 0xb91: 0x29f6,
+	0xb92: 0x2a03, 0xb93: 0x2bbe, 0xb94: 0x26bb, 0xb95: 0x2bd1, 0xb96: 0x2be4, 0xb97: 0x2b2c,
+	0xb98: 0x2a10, 0xb99: 0x2bf7, 0xb9a: 0x2c0a, 0xb9b: 0x2a1d, 0xb9c: 0x28bc, 0xb9d: 0x28c6,
+	0xb9e: 0x2eb7, 0xb9f: 0x2a2a, 0xba0: 0x2b3c, 0xba1: 0x2ef5, 0xba2: 0x28d0, 0xba3: 0x28da,
+	0xba4: 0x2a37, 0xba5: 0x28e4, 0xba6: 0x28ee, 0xba7: 0x26d0, 0xba8: 0x26d7, 0xba9: 0x28f8,
+	0xbaa: 0x2902, 0xbab: 0x2c1d, 0xbac: 0x2a44, 0xbad: 0x2b4c, 0xbae: 0x2c30, 0xbaf: 0x2a51,
+	0xbb0: 0x2916, 0xbb1: 0x290c, 0xbb2: 0x2f3c, 0xbb3: 0x2a5e, 0xbb4: 0x2c43, 0xbb5: 0x2920,
+	0xbb6: 0x2b5c, 0xbb7: 0x292a, 0xbb8: 0x2a78, 0xbb9: 0x2934, 0xbba: 0x2a85, 0xbbb: 0x2f06,
+	0xbbc: 0x2a6b, 0xbbd: 0x2b6c, 0xbbe: 0x2a92, 0xbbf: 0x26de,
+	// Block 0x2f, offset 0xbc0
+	0xbc0: 0x2f17, 0xbc1: 0x293e, 0xbc2: 0x2948, 0xbc3: 0x2a9f, 0xbc4: 0x2952, 0xbc5: 0x295c,
+	0xbc6: 0x2966, 0xbc7: 0x2b7c, 0xbc8: 0x2aac, 0xbc9: 0x26e5, 0xbca: 0x2c56, 0xbcb: 0x2e90,
+	0xbcc: 0x2b8c, 0xbcd: 0x2ab9, 0xbce: 0x2ec5, 0xbcf: 0x2970, 0xbd0: 0x297a, 0xbd1: 0x2ac6,
+	0xbd2: 0x26ec, 0xbd3: 0x2ad3, 0xbd4: 0x2b9c, 0xbd5: 0x26f3, 0xbd6: 0x2c69, 0xbd7: 0x2984,
+	0xbd8: 0x1cb7, 0xbd9: 0x1ccb, 0xbda: 0x1cda, 0xbdb: 0x1ce9, 0xbdc: 0x1cf8, 0xbdd: 0x1d07,
+	0xbde: 0x1d16, 0xbdf: 0x1d25, 0xbe0: 0x1d34, 0xbe1: 0x1d43, 0xbe2: 0x2192, 0xbe3: 0x21a4,
+	0xbe4: 0x21b6, 0xbe5: 0x21c2, 0xbe6: 0x21ce, 0xbe7: 0x21da, 0xbe8: 0x21e6, 0xbe9: 0x21f2,
+	0xbea: 0x21fe, 0xbeb: 0x220a, 0xbec: 0x2246, 0xbed: 0x2252, 0xbee: 0x225e, 0xbef: 0x226a,
+	0xbf0: 0x2276, 0xbf1: 0x1c14, 0xbf2: 0x19c6, 0xbf3: 0x1936, 0xbf4: 0x1be4, 0xbf5: 0x1a47,
+	0xbf6: 0x1a56, 0xbf7: 0x19cc, 0xbf8: 0x1bfc, 0xbf9: 0x1c00, 0xbfa: 0x1960, 0xbfb: 0x2701,
+	0xbfc: 0x270f, 0xbfd: 0x26fa, 0xbfe: 0x2708, 0xbff: 0x2ae0,
+	// Block 0x30, offset 0xc00
+	0xc00: 0x1a4a, 0xc01: 0x1a32, 0xc02: 0x1c60, 0xc03: 0x1a1a, 0xc04: 0x19f3, 0xc05: 0x1969,
+	0xc06: 0x1978, 0xc07: 0x1948, 0xc08: 0x1bf0, 0xc09: 0x1d52, 0xc0a: 0x1a4d, 0xc0b: 0x1a35,
+	0xc0c: 0x1c64, 0xc0d: 0x1c70, 0xc0e: 0x1a26, 0xc0f: 0x19fc, 0xc10: 0x1957, 0xc11: 0x1c1c,
+	0xc12: 0x1bb0, 0xc13: 0x1b9c, 0xc14: 0x1bcc, 0xc15: 0x1c74, 0xc16: 0x1a29, 0xc17: 0x19c9,
+	0xc18: 0x19ff, 0xc19: 0x19de, 0xc1a: 0x1a41, 0xc1b: 0x1c78, 0xc1c: 0x1a2c, 0xc1d: 0x19c0,
+	0xc1e: 0x1a02, 0xc1f: 0x1c3c, 0xc20: 0x1bf4, 0xc21: 0x1a14, 0xc22: 0x1c24, 0xc23: 0x1c40,
+	0xc24: 0x1bf8, 0xc25: 0x1a17, 0xc26: 0x1c28, 0xc27: 0x22e8, 0xc28: 0x22fc, 0xc29: 0x1996,
+	0xc2a: 0x1c20, 0xc2b: 0x1bb4, 0xc2c: 0x1ba0, 0xc2d: 0x1c48, 0xc2e: 0x2716, 0xc2f: 0x27ad,
+	0xc30: 0x1a59, 0xc31: 0x1a44, 0xc32: 0x1c7c, 0xc33: 0x1a2f, 0xc34: 0x1a50, 0xc35: 0x1a38,
+	0xc36: 0x1c68, 0xc37: 0x1a1d, 0xc38: 0x19f6, 0xc39: 0x1981, 0xc3a: 0x1a53, 0xc3b: 0x1a3b,
+	0xc3c: 0x1c6c, 0xc3d: 0x1a20, 0xc3e: 0x19f9, 0xc3f: 0x1984,
+	// Block 0x31, offset 0xc40
+	0xc40: 0x1c2c, 0xc41: 0x1bb8, 0xc42: 0x1d4d, 0xc43: 0x1939, 0xc44: 0x19ba, 0xc45: 0x19bd,
+	0xc46: 0x22f5, 0xc47: 0x1b94, 0xc48: 0x19c3, 0xc49: 0x194b, 0xc4a: 0x19e1, 0xc4b: 0x194e,
+	0xc4c: 0x19ea, 0xc4d: 0x196c, 0xc4e: 0x196f, 0xc4f: 0x1a05, 0xc50: 0x1a0b, 0xc51: 0x1a0e,
+	0xc52: 0x1c30, 0xc53: 0x1a11, 0xc54: 0x1a23, 0xc55: 0x1c38, 0xc56: 0x1c44, 0xc57: 0x1990,
+	0xc58: 0x1d57, 0xc59: 0x1bbc, 0xc5a: 0x1993, 0xc5b: 0x1a5c, 0xc5c: 0x19a5, 0xc5d: 0x19b4,
+	0xc5e: 0x22e2, 0xc5f: 0x22dc, 0xc60: 0x1cc1, 0xc61: 0x1cd0, 0xc62: 0x1cdf, 0xc63: 0x1cee,
+	0xc64: 0x1cfd, 0xc65: 0x1d0c, 0xc66: 0x1d1b, 0xc67: 0x1d2a, 0xc68: 0x1d39, 0xc69: 0x2186,
+	0xc6a: 0x2198, 0xc6b: 0x21aa, 0xc6c: 0x21bc, 0xc6d: 0x21c8, 0xc6e: 0x21d4, 0xc6f: 0x21e0,
+	0xc70: 0x21ec, 0xc71: 0x21f8, 0xc72: 0x2204, 0xc73: 0x2240, 0xc74: 0x224c, 0xc75: 0x2258,
+	0xc76: 0x2264, 0xc77: 0x2270, 0xc78: 0x227c, 0xc79: 0x2282, 0xc7a: 0x2288, 0xc7b: 0x228e,
+	0xc7c: 0x2294, 0xc7d: 0x22a6, 0xc7e: 0x22ac, 0xc7f: 0x1c10,
+	// Block 0x32, offset 0xc80
+	0xc80: 0x1377, 0xc81: 0x0cfb, 0xc82: 0x13d3, 0xc83: 0x139f, 0xc84: 0x0e57, 0xc85: 0x06eb,
+	0xc86: 0x08df, 0xc87: 0x162b, 0xc88: 0x162b, 0xc89: 0x0a0b, 0xc8a: 0x145f, 0xc8b: 0x0943,
+	0xc8c: 0x0a07, 0xc8d: 0x0bef, 0xc8e: 0x0fcf, 0xc8f: 0x115f, 0xc90: 0x1297, 0xc91: 0x12d3,
+	0xc92: 0x1307, 0xc93: 0x141b, 0xc94: 0x0d73, 0xc95: 0x0dff, 0xc96: 0x0eab, 0xc97: 0x0f43,
+	0xc98: 0x125f, 0xc99: 0x1447, 0xc9a: 0x1573, 0xc9b: 0x070f, 0xc9c: 0x08b3, 0xc9d: 0x0d87,
+	0xc9e: 0x0ecf, 0xc9f: 0x1293, 0xca0: 0x15c3, 0xca1: 0x0ab3, 0xca2: 0x0e77, 0xca3: 0x1283,
+	0xca4: 0x1317, 0xca5: 0x0c23, 0xca6: 0x11bb, 0xca7: 0x12df, 0xca8: 0x0b1f, 0xca9: 0x0d0f,
+	0xcaa: 0x0e17, 0xcab: 0x0f1b, 0xcac: 0x1427, 0xcad: 0x074f, 0xcae: 0x07e7, 0xcaf: 0x0853,
+	0xcb0: 0x0c8b, 0xcb1: 0x0d7f, 0xcb2: 0x0ecb, 0xcb3: 0x0fef, 0xcb4: 0x1177, 0xcb5: 0x128b,
+	0xcb6: 0x12a3, 0xcb7: 0x13c7, 0xcb8: 0x14ef, 0xcb9: 0x15a3, 0xcba: 0x15bf, 0xcbb: 0x102b,
+	0xcbc: 0x106b, 0xcbd: 0x1123, 0xcbe: 0x1243, 0xcbf: 0x147b,
+	// Block 0x33, offset 0xcc0
+	0xcc0: 0x15cb, 0xcc1: 0x134b, 0xcc2: 0x09c7, 0xcc3: 0x0b3b, 0xcc4: 0x10db, 0xcc5: 0x119b,
+	0xcc6: 0x0eff, 0xcc7: 0x1033, 0xcc8: 0x1397, 0xcc9: 0x14e7, 0xcca: 0x09c3, 0xccb: 0x0a8f,
+	0xccc: 0x0d77, 0xccd: 0x0e2b, 0xcce: 0x0e5f, 0xccf: 0x1113, 0xcd0: 0x113b, 0xcd1: 0x14a7,
+	0xcd2: 0x084f, 0xcd3: 0x11a7, 0xcd4: 0x07f3, 0xcd5: 0x07ef, 0xcd6: 0x1097, 0xcd7: 0x1127,
+	0xcd8: 0x125b, 0xcd9: 0x14af, 0xcda: 0x1367, 0xcdb: 0x0c27, 0xcdc: 0x0d73, 0xcdd: 0x1357,
+	0xcde: 0x06f7, 0xcdf: 0x0a63, 0xce0: 0x0b93, 0xce1: 0x0f2f, 0xce2: 0x0faf, 0xce3: 0x0873,
+	0xce4: 0x103b, 0xce5: 0x075f, 0xce6: 0x0b77, 0xce7: 0x06d7, 0xce8: 0x0deb, 0xce9: 0x0ca3,
+	0xcea: 0x110f, 0xceb: 0x08c7, 0xcec: 0x09b3, 0xced: 0x0ffb, 0xcee: 0x1263, 0xcef: 0x133b,
+	0xcf0: 0x0db7, 0xcf1: 0x13f7, 0xcf2: 0x0de3, 0xcf3: 0x0c37, 0xcf4: 0x121b, 0xcf5: 0x0c57,
+	0xcf6: 0x0fab, 0xcf7: 0x072b, 0xcf8: 0x07a7, 0xcf9: 0x07eb, 0xcfa: 0x0d53, 0xcfb: 0x10fb,
+	0xcfc: 0x11f3, 0xcfd: 0x1347, 0xcfe: 0x145b, 0xcff: 0x085b,
+	// Block 0x34, offset 0xd00
+	0xd00: 0x090f, 0xd01: 0x0a17, 0xd02: 0x0b2f, 0xd03: 0x0cbf, 0xd04: 0x0e7b, 0xd05: 0x103f,
+	0xd06: 0x1497, 0xd07: 0x157b, 0xd08: 0x15cf, 0xd09: 0x15e7, 0xd0a: 0x0837, 0xd0b: 0x0cf3,
+	0xd0c: 0x0da3, 0xd0d: 0x13eb, 0xd0e: 0x0afb, 0xd0f: 0x0bd7, 0xd10: 0x0bf3, 0xd11: 0x0c83,
+	0xd12: 0x0e6b, 0xd13: 0x0eb7, 0xd14: 0x0f67, 0xd15: 0x108b, 0xd16: 0x112f, 0xd17: 0x1193,
+	0xd18: 0x13db, 0xd19: 0x126b, 0xd1a: 0x1403, 0xd1b: 0x147f, 0xd1c: 0x080f, 0xd1d: 0x083b,
+	0xd1e: 0x0923, 0xd1f: 0x0ea7, 0xd20: 0x12f3, 0xd21: 0x133b, 0xd22: 0x0b1b, 0xd23: 0x0b8b,
+	0xd24: 0x0c4f, 0xd25: 0x0daf, 0xd26: 0x10d7, 0xd27: 0x0f23, 0xd28: 0x073b, 0xd29: 0x097f,
+	0xd2a: 0x0a63, 0xd2b: 0x0ac7, 0xd2c: 0x0b97, 0xd2d: 0x0f3f, 0xd2e: 0x0f5b, 0xd2f: 0x116b,
+	0xd30: 0x118b, 0xd31: 0x1463, 0xd32: 0x14e3, 0xd33: 0x14f3, 0xd34: 0x152f, 0xd35: 0x0753,
+	0xd36: 0x107f, 0xd37: 0x144f, 0xd38: 0x14cb, 0xd39: 0x0baf, 0xd3a: 0x0717, 0xd3b: 0x0777,
+	0xd3c: 0x0a67, 0xd3d: 0x0a87, 0xd3e: 0x0caf, 0xd3f: 0x0d73,
+	// Block 0x35, offset 0xd40
+	0xd40: 0x0ec3, 0xd41: 0x0fcb, 0xd42: 0x1277, 0xd43: 0x1417, 0xd44: 0x1623, 0xd45: 0x0ce3,
+	0xd46: 0x14a3, 0xd47: 0x0833, 0xd48: 0x0d2f, 0xd49: 0x0d3b, 0xd4a: 0x0e0f, 0xd4b: 0x0e47,
+	0xd4c: 0x0f4b, 0xd4d: 0x0fa7, 0xd4e: 0x1027, 0xd4f: 0x110b, 0xd50: 0x153b, 0xd51: 0x07af,
+	0xd52: 0x0c03, 0xd53: 0x14b3, 0xd54: 0x0767, 0xd55: 0x0aab, 0xd56: 0x0e2f, 0xd57: 0x13df,
+	0xd58: 0x0b67, 0xd59: 0x0bb7, 0xd5a: 0x0d43, 0xd5b: 0x0f2f, 0xd5c: 0x14bb, 0xd5d: 0x0817,
+	0xd5e: 0x08ff, 0xd5f: 0x0a97, 0xd60: 0x0cd3, 0xd61: 0x0d1f, 0xd62: 0x0d5f, 0xd63: 0x0df3,
+	0xd64: 0x0f47, 0xd65: 0x0fbb, 0xd66: 0x1157, 0xd67: 0x12f7, 0xd68: 0x1303, 0xd69: 0x1457,
+	0xd6a: 0x14d7, 0xd6b: 0x0883, 0xd6c: 0x0e4b, 0xd6d: 0x0903, 0xd6e: 0x0ec7, 0xd6f: 0x0f6b,
+	0xd70: 0x1287, 0xd71: 0x14bf, 0xd72: 0x15ab, 0xd73: 0x15d3, 0xd74: 0x0d37, 0xd75: 0x0e27,
+	0xd76: 0x11c3, 0xd77: 0x10b7, 0xd78: 0x10c3, 0xd79: 0x10e7, 0xd7a: 0x0f17, 0xd7b: 0x0e9f,
+	0xd7c: 0x1363, 0xd7d: 0x0733, 0xd7e: 0x122b, 0xd7f: 0x081b,
+	// Block 0x36, offset 0xd80
+	0xd80: 0x080b, 0xd81: 0x0b0b, 0xd82: 0x0c2b, 0xd83: 0x10f3, 0xd84: 0x0a53, 0xd85: 0x0e03,
+	0xd86: 0x0cef, 0xd87: 0x13e7, 0xd88: 0x12e7, 0xd89: 0x14ab, 0xd8a: 0x1323, 0xd8b: 0x0b27,
+	0xd8c: 0x0787, 0xd8d: 0x095b, 0xd90: 0x09af,
+	0xd92: 0x0cdf, 0xd95: 0x07f7, 0xd96: 0x0f1f, 0xd97: 0x0fe3,
+	0xd98: 0x1047, 0xd99: 0x1063, 0xd9a: 0x1067, 0xd9b: 0x107b, 0xd9c: 0x14fb, 0xd9d: 0x10eb,
+	0xd9e: 0x116f, 0xda0: 0x128f, 0xda2: 0x1353,
+	0xda5: 0x1407, 0xda6: 0x1433,
+	0xdaa: 0x154f, 0xdab: 0x1553, 0xdac: 0x1557, 0xdad: 0x15bb, 0xdae: 0x142b, 0xdaf: 0x14c7,
+	0xdb0: 0x0757, 0xdb1: 0x077b, 0xdb2: 0x078f, 0xdb3: 0x084b, 0xdb4: 0x0857, 0xdb5: 0x0897,
+	0xdb6: 0x094b, 0xdb7: 0x0967, 0xdb8: 0x096f, 0xdb9: 0x09ab, 0xdba: 0x09b7, 0xdbb: 0x0a93,
+	0xdbc: 0x0a9b, 0xdbd: 0x0ba3, 0xdbe: 0x0bcb, 0xdbf: 0x0bd3,
+	// Block 0x37, offset 0xdc0
+	0xdc0: 0x0beb, 0xdc1: 0x0c97, 0xdc2: 0x0cc7, 0xdc3: 0x0ce7, 0xdc4: 0x0d57, 0xdc5: 0x0e1b,
+	0xdc6: 0x0e37, 0xdc7: 0x0e67, 0xdc8: 0x0ebb, 0xdc9: 0x0edb, 0xdca: 0x0f4f, 0xdcb: 0x102f,
+	0xdcc: 0x104b, 0xdcd: 0x1053, 0xdce: 0x104f, 0xdcf: 0x1057, 0xdd0: 0x105b, 0xdd1: 0x105f,
+	0xdd2: 0x1073, 0xdd3: 0x1077, 0xdd4: 0x109b, 0xdd5: 0x10af, 0xdd6: 0x10cb, 0xdd7: 0x112f,
+	0xdd8: 0x1137, 0xdd9: 0x113f, 0xdda: 0x1153, 0xddb: 0x117b, 0xddc: 0x11cb, 0xddd: 0x11ff,
+	0xdde: 0x11ff, 0xddf: 0x1267, 0xde0: 0x130f, 0xde1: 0x1327, 0xde2: 0x135b, 0xde3: 0x135f,
+	0xde4: 0x13a3, 0xde5: 0x13a7, 0xde6: 0x13ff, 0xde7: 0x1407, 0xde8: 0x14db, 0xde9: 0x151f,
+	0xdea: 0x1537, 0xdeb: 0x0b9b, 0xdec: 0x171e, 0xded: 0x11e3,
+	0xdf0: 0x06df, 0xdf1: 0x07e3, 0xdf2: 0x07a3, 0xdf3: 0x074b, 0xdf4: 0x078b, 0xdf5: 0x07b7,
+	0xdf6: 0x0847, 0xdf7: 0x0863, 0xdf8: 0x094b, 0xdf9: 0x0937, 0xdfa: 0x0947, 0xdfb: 0x0963,
+	0xdfc: 0x09af, 0xdfd: 0x09bf, 0xdfe: 0x0a03, 0xdff: 0x0a0f,
+	// Block 0x38, offset 0xe00
+	0xe00: 0x0a2b, 0xe01: 0x0a3b, 0xe02: 0x0b23, 0xe03: 0x0b2b, 0xe04: 0x0b5b, 0xe05: 0x0b7b,
+	0xe06: 0x0bab, 0xe07: 0x0bc3, 0xe08: 0x0bb3, 0xe09: 0x0bd3, 0xe0a: 0x0bc7, 0xe0b: 0x0beb,
+	0xe0c: 0x0c07, 0xe0d: 0x0c5f, 0xe0e: 0x0c6b, 0xe0f: 0x0c73, 0xe10: 0x0c9b, 0xe11: 0x0cdf,
+	0xe12: 0x0d0f, 0xe13: 0x0d13, 0xe14: 0x0d27, 0xe15: 0x0da7, 0xe16: 0x0db7, 0xe17: 0x0e0f,
+	0xe18: 0x0e5b, 0xe19: 0x0e53, 0xe1a: 0x0e67, 0xe1b: 0x0e83, 0xe1c: 0x0ebb, 0xe1d: 0x1013,
+	0xe1e: 0x0edf, 0xe1f: 0x0f13, 0xe20: 0x0f1f, 0xe21: 0x0f5f, 0xe22: 0x0f7b, 0xe23: 0x0f9f,
+	0xe24: 0x0fc3, 0xe25: 0x0fc7, 0xe26: 0x0fe3, 0xe27: 0x0fe7, 0xe28: 0x0ff7, 0xe29: 0x100b,
+	0xe2a: 0x1007, 0xe2b: 0x1037, 0xe2c: 0x10b3, 0xe2d: 0x10cb, 0xe2e: 0x10e3, 0xe2f: 0x111b,
+	0xe30: 0x112f, 0xe31: 0x114b, 0xe32: 0x117b, 0xe33: 0x122f, 0xe34: 0x1257, 0xe35: 0x12cb,
+	0xe36: 0x1313, 0xe37: 0x131f, 0xe38: 0x1327, 0xe39: 0x133f, 0xe3a: 0x1353, 0xe3b: 0x1343,
+	0xe3c: 0x135b, 0xe3d: 0x1357, 0xe3e: 0x134f, 0xe3f: 0x135f,
+	// Block 0x39, offset 0xe40
+	0xe40: 0x136b, 0xe41: 0x13a7, 0xe42: 0x13e3, 0xe43: 0x1413, 0xe44: 0x144b, 0xe45: 0x146b,
+	0xe46: 0x14b7, 0xe47: 0x14db, 0xe48: 0x14fb, 0xe49: 0x150f, 0xe4a: 0x151f, 0xe4b: 0x152b,
+	0xe4c: 0x1537, 0xe4d: 0x158b, 0xe4e: 0x162b, 0xe4f: 0x16b5, 0xe50: 0x16b0, 0xe51: 0x16e2,
+	0xe52: 0x0607, 0xe53: 0x062f, 0xe54: 0x0633, 0xe55: 0x1764, 0xe56: 0x1791, 0xe57: 0x1809,
+	0xe58: 0x1617, 0xe59: 0x1627,
+	// Block 0x3a, offset 0xe80
+	0xe80: 0x19d5, 0xe81: 0x19d8, 0xe82: 0x19db, 0xe83: 0x1c08, 0xe84: 0x1c0c, 0xe85: 0x1a5f,
+	0xe86: 0x1a5f,
+	0xe93: 0x1d75, 0xe94: 0x1d66, 0xe95: 0x1d6b, 0xe96: 0x1d7a, 0xe97: 0x1d70,
+	0xe9d: 0x4390,
+	0xe9e: 0x8115, 0xe9f: 0x4402, 0xea0: 0x022d, 0xea1: 0x0215, 0xea2: 0x021e, 0xea3: 0x0221,
+	0xea4: 0x0224, 0xea5: 0x0227, 0xea6: 0x022a, 0xea7: 0x0230, 0xea8: 0x0233, 0xea9: 0x0017,
+	0xeaa: 0x43f0, 0xeab: 0x43f6, 0xeac: 0x44f4, 0xead: 0x44fc, 0xeae: 0x4348, 0xeaf: 0x434e,
+	0xeb0: 0x4354, 0xeb1: 0x435a, 0xeb2: 0x4366, 0xeb3: 0x436c, 0xeb4: 0x4372, 0xeb5: 0x437e,
+	0xeb6: 0x4384, 0xeb8: 0x438a, 0xeb9: 0x4396, 0xeba: 0x439c, 0xebb: 0x43a2,
+	0xebc: 0x43ae, 0xebe: 0x43b4,
+	// Block 0x3b, offset 0xec0
+	0xec0: 0x43ba, 0xec1: 0x43c0, 0xec3: 0x43c6, 0xec4: 0x43cc,
+	0xec6: 0x43d8, 0xec7: 0x43de, 0xec8: 0x43e4, 0xec9: 0x43ea, 0xeca: 0x43fc, 0xecb: 0x4378,
+	0xecc: 0x4360, 0xecd: 0x43a8, 0xece: 0x43d2, 0xecf: 0x1d7f, 0xed0: 0x0299, 0xed1: 0x0299,
+	0xed2: 0x02a2, 0xed3: 0x02a2, 0xed4: 0x02a2, 0xed5: 0x02a2, 0xed6: 0x02a5, 0xed7: 0x02a5,
+	0xed8: 0x02a5, 0xed9: 0x02a5, 0xeda: 0x02ab, 0xedb: 0x02ab, 0xedc: 0x02ab, 0xedd: 0x02ab,
+	0xede: 0x029f, 0xedf: 0x029f, 0xee0: 0x029f, 0xee1: 0x029f, 0xee2: 0x02a8, 0xee3: 0x02a8,
+	0xee4: 0x02a8, 0xee5: 0x02a8, 0xee6: 0x029c, 0xee7: 0x029c, 0xee8: 0x029c, 0xee9: 0x029c,
+	0xeea: 0x02cf, 0xeeb: 0x02cf, 0xeec: 0x02cf, 0xeed: 0x02cf, 0xeee: 0x02d2, 0xeef: 0x02d2,
+	0xef0: 0x02d2, 0xef1: 0x02d2, 0xef2: 0x02b1, 0xef3: 0x02b1, 0xef4: 0x02b1, 0xef5: 0x02b1,
+	0xef6: 0x02ae, 0xef7: 0x02ae, 0xef8: 0x02ae, 0xef9: 0x02ae, 0xefa: 0x02b4, 0xefb: 0x02b4,
+	0xefc: 0x02b4, 0xefd: 0x02b4, 0xefe: 0x02b7, 0xeff: 0x02b7,
+	// Block 0x3c, offset 0xf00
+	0xf00: 0x02b7, 0xf01: 0x02b7, 0xf02: 0x02c0, 0xf03: 0x02c0, 0xf04: 0x02bd, 0xf05: 0x02bd,
+	0xf06: 0x02c3, 0xf07: 0x02c3, 0xf08: 0x02ba, 0xf09: 0x02ba, 0xf0a: 0x02c9, 0xf0b: 0x02c9,
+	0xf0c: 0x02c6, 0xf0d: 0x02c6, 0xf0e: 0x02d5, 0xf0f: 0x02d5, 0xf10: 0x02d5, 0xf11: 0x02d5,
+	0xf12: 0x02db, 0xf13: 0x02db, 0xf14: 0x02db, 0xf15: 0x02db, 0xf16: 0x02e1, 0xf17: 0x02e1,
+	0xf18: 0x02e1, 0xf19: 0x02e1, 0xf1a: 0x02de, 0xf1b: 0x02de, 0xf1c: 0x02de, 0xf1d: 0x02de,
+	0xf1e: 0x02e4, 0xf1f: 0x02e4, 0xf20: 0x02e7, 0xf21: 0x02e7, 0xf22: 0x02e7, 0xf23: 0x02e7,
+	0xf24: 0x446e, 0xf25: 0x446e, 0xf26: 0x02ed, 0xf27: 0x02ed, 0xf28: 0x02ed, 0xf29: 0x02ed,
+	0xf2a: 0x02ea, 0xf2b: 0x02ea, 0xf2c: 0x02ea, 0xf2d: 0x02ea, 0xf2e: 0x0308, 0xf2f: 0x0308,
+	0xf30: 0x4468, 0xf31: 0x4468,
+	// Block 0x3d, offset 0xf40
+	0xf53: 0x02d8, 0xf54: 0x02d8, 0xf55: 0x02d8, 0xf56: 0x02d8, 0xf57: 0x02f6,
+	0xf58: 0x02f6, 0xf59: 0x02f3, 0xf5a: 0x02f3, 0xf5b: 0x02f9, 0xf5c: 0x02f9, 0xf5d: 0x204f,
+	0xf5e: 0x02ff, 0xf5f: 0x02ff, 0xf60: 0x02f0, 0xf61: 0x02f0, 0xf62: 0x02fc, 0xf63: 0x02fc,
+	0xf64: 0x0305, 0xf65: 0x0305, 0xf66: 0x0305, 0xf67: 0x0305, 0xf68: 0x028d, 0xf69: 0x028d,
+	0xf6a: 0x25aa, 0xf6b: 0x25aa, 0xf6c: 0x261a, 0xf6d: 0x261a, 0xf6e: 0x25e9, 0xf6f: 0x25e9,
+	0xf70: 0x2605, 0xf71: 0x2605, 0xf72: 0x25fe, 0xf73: 0x25fe, 0xf74: 0x260c, 0xf75: 0x260c,
+	0xf76: 0x2613, 0xf77: 0x2613, 0xf78: 0x2613, 0xf79: 0x25f0, 0xf7a: 0x25f0, 0xf7b: 0x25f0,
+	0xf7c: 0x0302, 0xf7d: 0x0302, 0xf7e: 0x0302, 0xf7f: 0x0302,
+	// Block 0x3e, offset 0xf80
+	0xf80: 0x25b1, 0xf81: 0x25b8, 0xf82: 0x25d4, 0xf83: 0x25f0, 0xf84: 0x25f7, 0xf85: 0x1d89,
+	0xf86: 0x1d8e, 0xf87: 0x1d93, 0xf88: 0x1da2, 0xf89: 0x1db1, 0xf8a: 0x1db6, 0xf8b: 0x1dbb,
+	0xf8c: 0x1dc0, 0xf8d: 0x1dc5, 0xf8e: 0x1dd4, 0xf8f: 0x1de3, 0xf90: 0x1de8, 0xf91: 0x1ded,
+	0xf92: 0x1dfc, 0xf93: 0x1e0b, 0xf94: 0x1e10, 0xf95: 0x1e15, 0xf96: 0x1e1a, 0xf97: 0x1e29,
+	0xf98: 0x1e2e, 0xf99: 0x1e3d, 0xf9a: 0x1e42, 0xf9b: 0x1e47, 0xf9c: 0x1e56, 0xf9d: 0x1e5b,
+	0xf9e: 0x1e60, 0xf9f: 0x1e6a, 0xfa0: 0x1ea6, 0xfa1: 0x1eb5, 0xfa2: 0x1ec4, 0xfa3: 0x1ec9,
+	0xfa4: 0x1ece, 0xfa5: 0x1ed8, 0xfa6: 0x1ee7, 0xfa7: 0x1eec, 0xfa8: 0x1efb, 0xfa9: 0x1f00,
+	0xfaa: 0x1f05, 0xfab: 0x1f14, 0xfac: 0x1f19, 0xfad: 0x1f28, 0xfae: 0x1f2d, 0xfaf: 0x1f32,
+	0xfb0: 0x1f37, 0xfb1: 0x1f3c, 0xfb2: 0x1f41, 0xfb3: 0x1f46, 0xfb4: 0x1f4b, 0xfb5: 0x1f50,
+	0xfb6: 0x1f55, 0xfb7: 0x1f5a, 0xfb8: 0x1f5f, 0xfb9: 0x1f64, 0xfba: 0x1f69, 0xfbb: 0x1f6e,
+	0xfbc: 0x1f73, 0xfbd: 0x1f78, 0xfbe: 0x1f7d, 0xfbf: 0x1f87,
+	// Block 0x3f, offset 0xfc0
+	0xfc0: 0x1f8c, 0xfc1: 0x1f91, 0xfc2: 0x1f96, 0xfc3: 0x1fa0, 0xfc4: 0x1fa5, 0xfc5: 0x1faf,
+	0xfc6: 0x1fb4, 0xfc7: 0x1fb9, 0xfc8: 0x1fbe, 0xfc9: 0x1fc3, 0xfca: 0x1fc8, 0xfcb: 0x1fcd,
+	0xfcc: 0x1fd2, 0xfcd: 0x1fd7, 0xfce: 0x1fe6, 0xfcf: 0x1ff5, 0xfd0: 0x1ffa, 0xfd1: 0x1fff,
+	0xfd2: 0x2004, 0xfd3: 0x2009, 0xfd4: 0x200e, 0xfd5: 0x2018, 0xfd6: 0x201d, 0xfd7: 0x2022,
+	0xfd8: 0x2031, 0xfd9: 0x2040, 0xfda: 0x2045, 0xfdb: 0x4420, 0xfdc: 0x4426, 0xfdd: 0x445c,
+	0xfde: 0x44b3, 0xfdf: 0x44ba, 0xfe0: 0x44c1, 0xfe1: 0x44c8, 0xfe2: 0x44cf, 0xfe3: 0x44d6,
+	0xfe4: 0x25c6, 0xfe5: 0x25cd, 0xfe6: 0x25d4, 0xfe7: 0x25db, 0xfe8: 0x25f0, 0xfe9: 0x25f7,
+	0xfea: 0x1d98, 0xfeb: 0x1d9d, 0xfec: 0x1da2, 0xfed: 0x1da7, 0xfee: 0x1db1, 0xfef: 0x1db6,
+	0xff0: 0x1dca, 0xff1: 0x1dcf, 0xff2: 0x1dd4, 0xff3: 0x1dd9, 0xff4: 0x1de3, 0xff5: 0x1de8,
+	0xff6: 0x1df2, 0xff7: 0x1df7, 0xff8: 0x1dfc, 0xff9: 0x1e01, 0xffa: 0x1e0b, 0xffb: 0x1e10,
+	0xffc: 0x1f3c, 0xffd: 0x1f41, 0xffe: 0x1f50, 0xfff: 0x1f55,
+	// Block 0x40, offset 0x1000
+	0x1000: 0x1f5a, 0x1001: 0x1f6e, 0x1002: 0x1f73, 0x1003: 0x1f78, 0x1004: 0x1f7d, 0x1005: 0x1f96,
+	0x1006: 0x1fa0, 0x1007: 0x1fa5, 0x1008: 0x1faa, 0x1009: 0x1fbe, 0x100a: 0x1fdc, 0x100b: 0x1fe1,
+	0x100c: 0x1fe6, 0x100d: 0x1feb, 0x100e: 0x1ff5, 0x100f: 0x1ffa, 0x1010: 0x445c, 0x1011: 0x2027,
+	0x1012: 0x202c, 0x1013: 0x2031, 0x1014: 0x2036, 0x1015: 0x2040, 0x1016: 0x2045, 0x1017: 0x25b1,
+	0x1018: 0x25b8, 0x1019: 0x25bf, 0x101a: 0x25d4, 0x101b: 0x25e2, 0x101c: 0x1d89, 0x101d: 0x1d8e,
+	0x101e: 0x1d93, 0x101f: 0x1da2, 0x1020: 0x1dac, 0x1021: 0x1dbb, 0x1022: 0x1dc0, 0x1023: 0x1dc5,
+	0x1024: 0x1dd4, 0x1025: 0x1dde, 0x1026: 0x1dfc, 0x1027: 0x1e15, 0x1028: 0x1e1a, 0x1029: 0x1e29,
+	0x102a: 0x1e2e, 0x102b: 0x1e3d, 0x102c: 0x1e47, 0x102d: 0x1e56, 0x102e: 0x1e5b, 0x102f: 0x1e60,
+	0x1030: 0x1e6a, 0x1031: 0x1ea6, 0x1032: 0x1eab, 0x1033: 0x1eb5, 0x1034: 0x1ec4, 0x1035: 0x1ec9,
+	0x1036: 0x1ece, 0x1037: 0x1ed8, 0x1038: 0x1ee7, 0x1039: 0x1efb, 0x103a: 0x1f00, 0x103b: 0x1f05,
+	0x103c: 0x1f14, 0x103d: 0x1f19, 0x103e: 0x1f28, 0x103f: 0x1f2d,
+	// Block 0x41, offset 0x1040
+	0x1040: 0x1f32, 0x1041: 0x1f37, 0x1042: 0x1f46, 0x1043: 0x1f4b, 0x1044: 0x1f5f, 0x1045: 0x1f64,
+	0x1046: 0x1f69, 0x1047: 0x1f6e, 0x1048: 0x1f73, 0x1049: 0x1f87, 0x104a: 0x1f8c, 0x104b: 0x1f91,
+	0x104c: 0x1f96, 0x104d: 0x1f9b, 0x104e: 0x1faf, 0x104f: 0x1fb4, 0x1050: 0x1fb9, 0x1051: 0x1fbe,
+	0x1052: 0x1fcd, 0x1053: 0x1fd2, 0x1054: 0x1fd7, 0x1055: 0x1fe6, 0x1056: 0x1ff0, 0x1057: 0x1fff,
+	0x1058: 0x2004, 0x1059: 0x4450, 0x105a: 0x2018, 0x105b: 0x201d, 0x105c: 0x2022, 0x105d: 0x2031,
+	0x105e: 0x203b, 0x105f: 0x25d4, 0x1060: 0x25e2, 0x1061: 0x1da2, 0x1062: 0x1dac, 0x1063: 0x1dd4,
+	0x1064: 0x1dde, 0x1065: 0x1dfc, 0x1066: 0x1e06, 0x1067: 0x1e6a, 0x1068: 0x1e6f, 0x1069: 0x1e92,
+	0x106a: 0x1e97, 0x106b: 0x1f6e, 0x106c: 0x1f73, 0x106d: 0x1f96, 0x106e: 0x1fe6, 0x106f: 0x1ff0,
+	0x1070: 0x2031, 0x1071: 0x203b, 0x1072: 0x4504, 0x1073: 0x450c, 0x1074: 0x4514, 0x1075: 0x1ef1,
+	0x1076: 0x1ef6, 0x1077: 0x1f0a, 0x1078: 0x1f0f, 0x1079: 0x1f1e, 0x107a: 0x1f23, 0x107b: 0x1e74,
+	0x107c: 0x1e79, 0x107d: 0x1e9c, 0x107e: 0x1ea1, 0x107f: 0x1e33,
+	// Block 0x42, offset 0x1080
+	0x1080: 0x1e38, 0x1081: 0x1e1f, 0x1082: 0x1e24, 0x1083: 0x1e4c, 0x1084: 0x1e51, 0x1085: 0x1eba,
+	0x1086: 0x1ebf, 0x1087: 0x1edd, 0x1088: 0x1ee2, 0x1089: 0x1e7e, 0x108a: 0x1e83, 0x108b: 0x1e88,
+	0x108c: 0x1e92, 0x108d: 0x1e8d, 0x108e: 0x1e65, 0x108f: 0x1eb0, 0x1090: 0x1ed3, 0x1091: 0x1ef1,
+	0x1092: 0x1ef6, 0x1093: 0x1f0a, 0x1094: 0x1f0f, 0x1095: 0x1f1e, 0x1096: 0x1f23, 0x1097: 0x1e74,
+	0x1098: 0x1e79, 0x1099: 0x1e9c, 0x109a: 0x1ea1, 0x109b: 0x1e33, 0x109c: 0x1e38, 0x109d: 0x1e1f,
+	0x109e: 0x1e24, 0x109f: 0x1e4c, 0x10a0: 0x1e51, 0x10a1: 0x1eba, 0x10a2: 0x1ebf, 0x10a3: 0x1edd,
+	0x10a4: 0x1ee2, 0x10a5: 0x1e7e, 0x10a6: 0x1e83, 0x10a7: 0x1e88, 0x10a8: 0x1e92, 0x10a9: 0x1e8d,
+	0x10aa: 0x1e65, 0x10ab: 0x1eb0, 0x10ac: 0x1ed3, 0x10ad: 0x1e7e, 0x10ae: 0x1e83, 0x10af: 0x1e88,
+	0x10b0: 0x1e92, 0x10b1: 0x1e6f, 0x10b2: 0x1e97, 0x10b3: 0x1eec, 0x10b4: 0x1e56, 0x10b5: 0x1e5b,
+	0x10b6: 0x1e60, 0x10b7: 0x1e7e, 0x10b8: 0x1e83, 0x10b9: 0x1e88, 0x10ba: 0x1eec, 0x10bb: 0x1efb,
+	0x10bc: 0x4408, 0x10bd: 0x4408,
+	// Block 0x43, offset 0x10c0
+	0x10d0: 0x2311, 0x10d1: 0x2326,
+	0x10d2: 0x2326, 0x10d3: 0x232d, 0x10d4: 0x2334, 0x10d5: 0x2349, 0x10d6: 0x2350, 0x10d7: 0x2357,
+	0x10d8: 0x237a, 0x10d9: 0x237a, 0x10da: 0x239d, 0x10db: 0x2396, 0x10dc: 0x23b2, 0x10dd: 0x23a4,
+	0x10de: 0x23ab, 0x10df: 0x23ce, 0x10e0: 0x23ce, 0x10e1: 0x23c7, 0x10e2: 0x23d5, 0x10e3: 0x23d5,
+	0x10e4: 0x23ff, 0x10e5: 0x23ff, 0x10e6: 0x241b, 0x10e7: 0x23e3, 0x10e8: 0x23e3, 0x10e9: 0x23dc,
+	0x10ea: 0x23f1, 0x10eb: 0x23f1, 0x10ec: 0x23f8, 0x10ed: 0x23f8, 0x10ee: 0x2422, 0x10ef: 0x2430,
+	0x10f0: 0x2430, 0x10f1: 0x2437, 0x10f2: 0x2437, 0x10f3: 0x243e, 0x10f4: 0x2445, 0x10f5: 0x244c,
+	0x10f6: 0x2453, 0x10f7: 0x2453, 0x10f8: 0x245a, 0x10f9: 0x2468, 0x10fa: 0x2476, 0x10fb: 0x246f,
+	0x10fc: 0x247d, 0x10fd: 0x247d, 0x10fe: 0x2492, 0x10ff: 0x2499,
+	// Block 0x44, offset 0x1100
+	0x1100: 0x24ca, 0x1101: 0x24d8, 0x1102: 0x24d1, 0x1103: 0x24b5, 0x1104: 0x24b5, 0x1105: 0x24df,
+	0x1106: 0x24df, 0x1107: 0x24e6, 0x1108: 0x24e6, 0x1109: 0x2510, 0x110a: 0x2517, 0x110b: 0x251e,
+	0x110c: 0x24f4, 0x110d: 0x2502, 0x110e: 0x2525, 0x110f: 0x252c,
+	0x1112: 0x24fb, 0x1113: 0x2580, 0x1114: 0x2587, 0x1115: 0x255d, 0x1116: 0x2564, 0x1117: 0x2548,
+	0x1118: 0x2548, 0x1119: 0x254f, 0x111a: 0x2579, 0x111b: 0x2572, 0x111c: 0x259c, 0x111d: 0x259c,
+	0x111e: 0x230a, 0x111f: 0x231f, 0x1120: 0x2318, 0x1121: 0x2342, 0x1122: 0x233b, 0x1123: 0x2365,
+	0x1124: 0x235e, 0x1125: 0x2388, 0x1126: 0x236c, 0x1127: 0x2381, 0x1128: 0x23b9, 0x1129: 0x2406,
+	0x112a: 0x23ea, 0x112b: 0x2429, 0x112c: 0x24c3, 0x112d: 0x24ed, 0x112e: 0x2595, 0x112f: 0x258e,
+	0x1130: 0x25a3, 0x1131: 0x253a, 0x1132: 0x24a0, 0x1133: 0x256b, 0x1134: 0x2492, 0x1135: 0x24ca,
+	0x1136: 0x2461, 0x1137: 0x24ae, 0x1138: 0x2541, 0x1139: 0x2533, 0x113a: 0x24bc, 0x113b: 0x24a7,
+	0x113c: 0x24bc, 0x113d: 0x2541, 0x113e: 0x2373, 0x113f: 0x238f,
+	// Block 0x45, offset 0x1140
+	0x1140: 0x2509, 0x1141: 0x2484, 0x1142: 0x2303, 0x1143: 0x24a7, 0x1144: 0x244c, 0x1145: 0x241b,
+	0x1146: 0x23c0, 0x1147: 0x2556,
+	0x1170: 0x2414, 0x1171: 0x248b, 0x1172: 0x27bf, 0x1173: 0x27b6, 0x1174: 0x27ec, 0x1175: 0x27da,
+	0x1176: 0x27c8, 0x1177: 0x27e3, 0x1178: 0x27f5, 0x1179: 0x240d, 0x117a: 0x2c7c, 0x117b: 0x2afc,
+	0x117c: 0x27d1,
+	// Block 0x46, offset 0x1180
+	0x1190: 0x0019, 0x1191: 0x0483,
+	0x1192: 0x0487, 0x1193: 0x0035, 0x1194: 0x0037, 0x1195: 0x0003, 0x1196: 0x003f, 0x1197: 0x04bf,
+	0x1198: 0x04c3, 0x1199: 0x1b5c,
+	0x11a0: 0x8132, 0x11a1: 0x8132, 0x11a2: 0x8132, 0x11a3: 0x8132,
+	0x11a4: 0x8132, 0x11a5: 0x8132, 0x11a6: 0x8132, 0x11a7: 0x812d, 0x11a8: 0x812d, 0x11a9: 0x812d,
+	0x11aa: 0x812d, 0x11ab: 0x812d, 0x11ac: 0x812d, 0x11ad: 0x812d, 0x11ae: 0x8132, 0x11af: 0x8132,
+	0x11b0: 0x1873, 0x11b1: 0x0443, 0x11b2: 0x043f, 0x11b3: 0x007f, 0x11b4: 0x007f, 0x11b5: 0x0011,
+	0x11b6: 0x0013, 0x11b7: 0x00b7, 0x11b8: 0x00bb, 0x11b9: 0x04b7, 0x11ba: 0x04bb, 0x11bb: 0x04ab,
+	0x11bc: 0x04af, 0x11bd: 0x0493, 0x11be: 0x0497, 0x11bf: 0x048b,
+	// Block 0x47, offset 0x11c0
+	0x11c0: 0x048f, 0x11c1: 0x049b, 0x11c2: 0x049f, 0x11c3: 0x04a3, 0x11c4: 0x04a7,
+	0x11c7: 0x0077, 0x11c8: 0x007b, 0x11c9: 0x4269, 0x11ca: 0x4269, 0x11cb: 0x4269,
+	0x11cc: 0x4269, 0x11cd: 0x007f, 0x11ce: 0x007f, 0x11cf: 0x007f, 0x11d0: 0x0019, 0x11d1: 0x0483,
+	0x11d2: 0x001d, 0x11d4: 0x0037, 0x11d5: 0x0035, 0x11d6: 0x003f, 0x11d7: 0x0003,
+	0x11d8: 0x0443, 0x11d9: 0x0011, 0x11da: 0x0013, 0x11db: 0x00b7, 0x11dc: 0x00bb, 0x11dd: 0x04b7,
+	0x11de: 0x04bb, 0x11df: 0x0007, 0x11e0: 0x000d, 0x11e1: 0x0015, 0x11e2: 0x0017, 0x11e3: 0x001b,
+	0x11e4: 0x0039, 0x11e5: 0x003d, 0x11e6: 0x003b, 0x11e8: 0x0079, 0x11e9: 0x0009,
+	0x11ea: 0x000b, 0x11eb: 0x0041,
+	0x11f0: 0x42aa, 0x11f1: 0x442c, 0x11f2: 0x42af, 0x11f4: 0x42b4,
+	0x11f6: 0x42b9, 0x11f7: 0x4432, 0x11f8: 0x42be, 0x11f9: 0x4438, 0x11fa: 0x42c3, 0x11fb: 0x443e,
+	0x11fc: 0x42c8, 0x11fd: 0x4444, 0x11fe: 0x42cd, 0x11ff: 0x444a,
+	// Block 0x48, offset 0x1200
+	0x1200: 0x0236, 0x1201: 0x440e, 0x1202: 0x440e, 0x1203: 0x4414, 0x1204: 0x4414, 0x1205: 0x4456,
+	0x1206: 0x4456, 0x1207: 0x441a, 0x1208: 0x441a, 0x1209: 0x4462, 0x120a: 0x4462, 0x120b: 0x4462,
+	0x120c: 0x4462, 0x120d: 0x0239, 0x120e: 0x0239, 0x120f: 0x023c, 0x1210: 0x023c, 0x1211: 0x023c,
+	0x1212: 0x023c, 0x1213: 0x023f, 0x1214: 0x023f, 0x1215: 0x0242, 0x1216: 0x0242, 0x1217: 0x0242,
+	0x1218: 0x0242, 0x1219: 0x0245, 0x121a: 0x0245, 0x121b: 0x0245, 0x121c: 0x0245, 0x121d: 0x0248,
+	0x121e: 0x0248, 0x121f: 0x0248, 0x1220: 0x0248, 0x1221: 0x024b, 0x1222: 0x024b, 0x1223: 0x024b,
+	0x1224: 0x024b, 0x1225: 0x024e, 0x1226: 0x024e, 0x1227: 0x024e, 0x1228: 0x024e, 0x1229: 0x0251,
+	0x122a: 0x0251, 0x122b: 0x0254, 0x122c: 0x0254, 0x122d: 0x0257, 0x122e: 0x0257, 0x122f: 0x025a,
+	0x1230: 0x025a, 0x1231: 0x025d, 0x1232: 0x025d, 0x1233: 0x025d, 0x1234: 0x025d, 0x1235: 0x0260,
+	0x1236: 0x0260, 0x1237: 0x0260, 0x1238: 0x0260, 0x1239: 0x0263, 0x123a: 0x0263, 0x123b: 0x0263,
+	0x123c: 0x0263, 0x123d: 0x0266, 0x123e: 0x0266, 0x123f: 0x0266,
+	// Block 0x49, offset 0x1240
+	0x1240: 0x0266, 0x1241: 0x0269, 0x1242: 0x0269, 0x1243: 0x0269, 0x1244: 0x0269, 0x1245: 0x026c,
+	0x1246: 0x026c, 0x1247: 0x026c, 0x1248: 0x026c, 0x1249: 0x026f, 0x124a: 0x026f, 0x124b: 0x026f,
+	0x124c: 0x026f, 0x124d: 0x0272, 0x124e: 0x0272, 0x124f: 0x0272, 0x1250: 0x0272, 0x1251: 0x0275,
+	0x1252: 0x0275, 0x1253: 0x0275, 0x1254: 0x0275, 0x1255: 0x0278, 0x1256: 0x0278, 0x1257: 0x0278,
+	0x1258: 0x0278, 0x1259: 0x027b, 0x125a: 0x027b, 0x125b: 0x027b, 0x125c: 0x027b, 0x125d: 0x027e,
+	0x125e: 0x027e, 0x125f: 0x027e, 0x1260: 0x027e, 0x1261: 0x0281, 0x1262: 0x0281, 0x1263: 0x0281,
+	0x1264: 0x0281, 0x1265: 0x0284, 0x1266: 0x0284, 0x1267: 0x0284, 0x1268: 0x0284, 0x1269: 0x0287,
+	0x126a: 0x0287, 0x126b: 0x0287, 0x126c: 0x0287, 0x126d: 0x028a, 0x126e: 0x028a, 0x126f: 0x028d,
+	0x1270: 0x028d, 0x1271: 0x0290, 0x1272: 0x0290, 0x1273: 0x0290, 0x1274: 0x0290, 0x1275: 0x2e00,
+	0x1276: 0x2e00, 0x1277: 0x2e08, 0x1278: 0x2e08, 0x1279: 0x2e10, 0x127a: 0x2e10, 0x127b: 0x1f82,
+	0x127c: 0x1f82,
+	// Block 0x4a, offset 0x1280
+	0x1280: 0x0081, 0x1281: 0x0083, 0x1282: 0x0085, 0x1283: 0x0087, 0x1284: 0x0089, 0x1285: 0x008b,
+	0x1286: 0x008d, 0x1287: 0x008f, 0x1288: 0x0091, 0x1289: 0x0093, 0x128a: 0x0095, 0x128b: 0x0097,
+	0x128c: 0x0099, 0x128d: 0x009b, 0x128e: 0x009d, 0x128f: 0x009f, 0x1290: 0x00a1, 0x1291: 0x00a3,
+	0x1292: 0x00a5, 0x1293: 0x00a7, 0x1294: 0x00a9, 0x1295: 0x00ab, 0x1296: 0x00ad, 0x1297: 0x00af,
+	0x1298: 0x00b1, 0x1299: 0x00b3, 0x129a: 0x00b5, 0x129b: 0x00b7, 0x129c: 0x00b9, 0x129d: 0x00bb,
+	0x129e: 0x00bd, 0x129f: 0x0477, 0x12a0: 0x047b, 0x12a1: 0x0487, 0x12a2: 0x049b, 0x12a3: 0x049f,
+	0x12a4: 0x0483, 0x12a5: 0x05ab, 0x12a6: 0x05a3, 0x12a7: 0x04c7, 0x12a8: 0x04cf, 0x12a9: 0x04d7,
+	0x12aa: 0x04df, 0x12ab: 0x04e7, 0x12ac: 0x056b, 0x12ad: 0x0573, 0x12ae: 0x057b, 0x12af: 0x051f,
+	0x12b0: 0x05af, 0x12b1: 0x04cb, 0x12b2: 0x04d3, 0x12b3: 0x04db, 0x12b4: 0x04e3, 0x12b5: 0x04eb,
+	0x12b6: 0x04ef, 0x12b7: 0x04f3, 0x12b8: 0x04f7, 0x12b9: 0x04fb, 0x12ba: 0x04ff, 0x12bb: 0x0503,
+	0x12bc: 0x0507, 0x12bd: 0x050b, 0x12be: 0x050f, 0x12bf: 0x0513,
+	// Block 0x4b, offset 0x12c0
+	0x12c0: 0x0517, 0x12c1: 0x051b, 0x12c2: 0x0523, 0x12c3: 0x0527, 0x12c4: 0x052b, 0x12c5: 0x052f,
+	0x12c6: 0x0533, 0x12c7: 0x0537, 0x12c8: 0x053b, 0x12c9: 0x053f, 0x12ca: 0x0543, 0x12cb: 0x0547,
+	0x12cc: 0x054b, 0x12cd: 0x054f, 0x12ce: 0x0553, 0x12cf: 0x0557, 0x12d0: 0x055b, 0x12d1: 0x055f,
+	0x12d2: 0x0563, 0x12d3: 0x0567, 0x12d4: 0x056f, 0x12d5: 0x0577, 0x12d6: 0x057f, 0x12d7: 0x0583,
+	0x12d8: 0x0587, 0x12d9: 0x058b, 0x12da: 0x058f, 0x12db: 0x0593, 0x12dc: 0x0597, 0x12dd: 0x05a7,
+	0x12de: 0x4a78, 0x12df: 0x4a7e, 0x12e0: 0x03c3, 0x12e1: 0x0313, 0x12e2: 0x0317, 0x12e3: 0x4a3b,
+	0x12e4: 0x031b, 0x12e5: 0x4a41, 0x12e6: 0x4a47, 0x12e7: 0x031f, 0x12e8: 0x0323, 0x12e9: 0x0327,
+	0x12ea: 0x4a4d, 0x12eb: 0x4a53, 0x12ec: 0x4a59, 0x12ed: 0x4a5f, 0x12ee: 0x4a65, 0x12ef: 0x4a6b,
+	0x12f0: 0x0367, 0x12f1: 0x032b, 0x12f2: 0x032f, 0x12f3: 0x0333, 0x12f4: 0x037b, 0x12f5: 0x0337,
+	0x12f6: 0x033b, 0x12f7: 0x033f, 0x12f8: 0x0343, 0x12f9: 0x0347, 0x12fa: 0x034b, 0x12fb: 0x034f,
+	0x12fc: 0x0353, 0x12fd: 0x0357, 0x12fe: 0x035b,
+	// Block 0x4c, offset 0x1300
+	0x1302: 0x49bd, 0x1303: 0x49c3, 0x1304: 0x49c9, 0x1305: 0x49cf,
+	0x1306: 0x49d5, 0x1307: 0x49db, 0x130a: 0x49e1, 0x130b: 0x49e7,
+	0x130c: 0x49ed, 0x130d: 0x49f3, 0x130e: 0x49f9, 0x130f: 0x49ff,
+	0x1312: 0x4a05, 0x1313: 0x4a0b, 0x1314: 0x4a11, 0x1315: 0x4a17, 0x1316: 0x4a1d, 0x1317: 0x4a23,
+	0x131a: 0x4a29, 0x131b: 0x4a2f, 0x131c: 0x4a35,
+	0x1320: 0x00bf, 0x1321: 0x00c2, 0x1322: 0x00cb, 0x1323: 0x4264,
+	0x1324: 0x00c8, 0x1325: 0x00c5, 0x1326: 0x0447, 0x1328: 0x046b, 0x1329: 0x044b,
+	0x132a: 0x044f, 0x132b: 0x0453, 0x132c: 0x0457, 0x132d: 0x046f, 0x132e: 0x0473,
+	// Block 0x4d, offset 0x1340
+	0x1340: 0x0063, 0x1341: 0x0065, 0x1342: 0x0067, 0x1343: 0x0069, 0x1344: 0x006b, 0x1345: 0x006d,
+	0x1346: 0x006f, 0x1347: 0x0071, 0x1348: 0x0073, 0x1349: 0x0075, 0x134a: 0x0083, 0x134b: 0x0085,
+	0x134c: 0x0087, 0x134d: 0x0089, 0x134e: 0x008b, 0x134f: 0x008d, 0x1350: 0x008f, 0x1351: 0x0091,
+	0x1352: 0x0093, 0x1353: 0x0095, 0x1354: 0x0097, 0x1355: 0x0099, 0x1356: 0x009b, 0x1357: 0x009d,
+	0x1358: 0x009f, 0x1359: 0x00a1, 0x135a: 0x00a3, 0x135b: 0x00a5, 0x135c: 0x00a7, 0x135d: 0x00a9,
+	0x135e: 0x00ab, 0x135f: 0x00ad, 0x1360: 0x00af, 0x1361: 0x00b1, 0x1362: 0x00b3, 0x1363: 0x00b5,
+	0x1364: 0x00dd, 0x1365: 0x00f2, 0x1368: 0x0173, 0x1369: 0x0176,
+	0x136a: 0x0179, 0x136b: 0x017c, 0x136c: 0x017f, 0x136d: 0x0182, 0x136e: 0x0185, 0x136f: 0x0188,
+	0x1370: 0x018b, 0x1371: 0x018e, 0x1372: 0x0191, 0x1373: 0x0194, 0x1374: 0x0197, 0x1375: 0x019a,
+	0x1376: 0x019d, 0x1377: 0x01a0, 0x1378: 0x01a3, 0x1379: 0x0188, 0x137a: 0x01a6, 0x137b: 0x01a9,
+	0x137c: 0x01ac, 0x137d: 0x01af, 0x137e: 0x01b2, 0x137f: 0x01b5,
+	// Block 0x4e, offset 0x1380
+	0x1380: 0x01fd, 0x1381: 0x0200, 0x1382: 0x0203, 0x1383: 0x045b, 0x1384: 0x01c7, 0x1385: 0x01d0,
+	0x1386: 0x01d6, 0x1387: 0x01fa, 0x1388: 0x01eb, 0x1389: 0x01e8, 0x138a: 0x0206, 0x138b: 0x0209,
+	0x138e: 0x0021, 0x138f: 0x0023, 0x1390: 0x0025, 0x1391: 0x0027,
+	0x1392: 0x0029, 0x1393: 0x002b, 0x1394: 0x002d, 0x1395: 0x002f, 0x1396: 0x0031, 0x1397: 0x0033,
+	0x1398: 0x0021, 0x1399: 0x0023, 0x139a: 0x0025, 0x139b: 0x0027, 0x139c: 0x0029, 0x139d: 0x002b,
+	0x139e: 0x002d, 0x139f: 0x002f, 0x13a0: 0x0031, 0x13a1: 0x0033, 0x13a2: 0x0021, 0x13a3: 0x0023,
+	0x13a4: 0x0025, 0x13a5: 0x0027, 0x13a6: 0x0029, 0x13a7: 0x002b, 0x13a8: 0x002d, 0x13a9: 0x002f,
+	0x13aa: 0x0031, 0x13ab: 0x0033, 0x13ac: 0x0021, 0x13ad: 0x0023, 0x13ae: 0x0025, 0x13af: 0x0027,
+	0x13b0: 0x0029, 0x13b1: 0x002b, 0x13b2: 0x002d, 0x13b3: 0x002f, 0x13b4: 0x0031, 0x13b5: 0x0033,
+	0x13b6: 0x0021, 0x13b7: 0x0023, 0x13b8: 0x0025, 0x13b9: 0x0027, 0x13ba: 0x0029, 0x13bb: 0x002b,
+	0x13bc: 0x002d, 0x13bd: 0x002f, 0x13be: 0x0031, 0x13bf: 0x0033,
+	// Block 0x4f, offset 0x13c0
+	0x13c0: 0x0239, 0x13c1: 0x023c, 0x13c2: 0x0248, 0x13c3: 0x0251, 0x13c5: 0x028a,
+	0x13c6: 0x025a, 0x13c7: 0x024b, 0x13c8: 0x0269, 0x13c9: 0x0290, 0x13ca: 0x027b, 0x13cb: 0x027e,
+	0x13cc: 0x0281, 0x13cd: 0x0284, 0x13ce: 0x025d, 0x13cf: 0x026f, 0x13d0: 0x0275, 0x13d1: 0x0263,
+	0x13d2: 0x0278, 0x13d3: 0x0257, 0x13d4: 0x0260, 0x13d5: 0x0242, 0x13d6: 0x0245, 0x13d7: 0x024e,
+	0x13d8: 0x0254, 0x13d9: 0x0266, 0x13da: 0x026c, 0x13db: 0x0272, 0x13dc: 0x0293, 0x13dd: 0x02e4,
+	0x13de: 0x02cc, 0x13df: 0x0296, 0x13e1: 0x023c, 0x13e2: 0x0248,
+	0x13e4: 0x0287, 0x13e7: 0x024b, 0x13e9: 0x0290,
+	0x13ea: 0x027b, 0x13eb: 0x027e, 0x13ec: 0x0281, 0x13ed: 0x0284, 0x13ee: 0x025d, 0x13ef: 0x026f,
+	0x13f0: 0x0275, 0x13f1: 0x0263, 0x13f2: 0x0278, 0x13f4: 0x0260, 0x13f5: 0x0242,
+	0x13f6: 0x0245, 0x13f7: 0x024e, 0x13f9: 0x0266, 0x13fb: 0x0272,
+	// Block 0x50, offset 0x1400
+	0x1402: 0x0248,
+	0x1407: 0x024b, 0x1409: 0x0290, 0x140b: 0x027e,
+	0x140d: 0x0284, 0x140e: 0x025d, 0x140f: 0x026f, 0x1411: 0x0263,
+	0x1412: 0x0278, 0x1414: 0x0260, 0x1417: 0x024e,
+	0x1419: 0x0266, 0x141b: 0x0272, 0x141d: 0x02e4,
+	0x141f: 0x0296, 0x1421: 0x023c, 0x1422: 0x0248,
+	0x1424: 0x0287, 0x1427: 0x024b, 0x1428: 0x0269, 0x1429: 0x0290,
+	0x142a: 0x027b, 0x142c: 0x0281, 0x142d: 0x0284, 0x142e: 0x025d, 0x142f: 0x026f,
+	0x1430: 0x0275, 0x1431: 0x0263, 0x1432: 0x0278, 0x1434: 0x0260, 0x1435: 0x0242,
+	0x1436: 0x0245, 0x1437: 0x024e, 0x1439: 0x0266, 0x143a: 0x026c, 0x143b: 0x0272,
+	0x143c: 0x0293, 0x143e: 0x02cc,
+	// Block 0x51, offset 0x1440
+	0x1440: 0x0239, 0x1441: 0x023c, 0x1442: 0x0248, 0x1443: 0x0251, 0x1444: 0x0287, 0x1445: 0x028a,
+	0x1446: 0x025a, 0x1447: 0x024b, 0x1448: 0x0269, 0x1449: 0x0290, 0x144b: 0x027e,
+	0x144c: 0x0281, 0x144d: 0x0284, 0x144e: 0x025d, 0x144f: 0x026f, 0x1450: 0x0275, 0x1451: 0x0263,
+	0x1452: 0x0278, 0x1453: 0x0257, 0x1454: 0x0260, 0x1455: 0x0242, 0x1456: 0x0245, 0x1457: 0x024e,
+	0x1458: 0x0254, 0x1459: 0x0266, 0x145a: 0x026c, 0x145b: 0x0272,
+	0x1461: 0x023c, 0x1462: 0x0248, 0x1463: 0x0251,
+	0x1465: 0x028a, 0x1466: 0x025a, 0x1467: 0x024b, 0x1468: 0x0269, 0x1469: 0x0290,
+	0x146b: 0x027e, 0x146c: 0x0281, 0x146d: 0x0284, 0x146e: 0x025d, 0x146f: 0x026f,
+	0x1470: 0x0275, 0x1471: 0x0263, 0x1472: 0x0278, 0x1473: 0x0257, 0x1474: 0x0260, 0x1475: 0x0242,
+	0x1476: 0x0245, 0x1477: 0x024e, 0x1478: 0x0254, 0x1479: 0x0266, 0x147a: 0x026c, 0x147b: 0x0272,
+	// Block 0x52, offset 0x1480
+	0x1480: 0x1879, 0x1481: 0x1876, 0x1482: 0x187c, 0x1483: 0x18a0, 0x1484: 0x18c4, 0x1485: 0x18e8,
+	0x1486: 0x190c, 0x1487: 0x1915, 0x1488: 0x191b, 0x1489: 0x1921, 0x148a: 0x1927,
+	0x1490: 0x1a8c, 0x1491: 0x1a90,
+	0x1492: 0x1a94, 0x1493: 0x1a98, 0x1494: 0x1a9c, 0x1495: 0x1aa0, 0x1496: 0x1aa4, 0x1497: 0x1aa8,
+	0x1498: 0x1aac, 0x1499: 0x1ab0, 0x149a: 0x1ab4, 0x149b: 0x1ab8, 0x149c: 0x1abc, 0x149d: 0x1ac0,
+	0x149e: 0x1ac4, 0x149f: 0x1ac8, 0x14a0: 0x1acc, 0x14a1: 0x1ad0, 0x14a2: 0x1ad4, 0x14a3: 0x1ad8,
+	0x14a4: 0x1adc, 0x14a5: 0x1ae0, 0x14a6: 0x1ae4, 0x14a7: 0x1ae8, 0x14a8: 0x1aec, 0x14a9: 0x1af0,
+	0x14aa: 0x271e, 0x14ab: 0x0047, 0x14ac: 0x0065, 0x14ad: 0x193c, 0x14ae: 0x19b1,
+	0x14b0: 0x0043, 0x14b1: 0x0045, 0x14b2: 0x0047, 0x14b3: 0x0049, 0x14b4: 0x004b, 0x14b5: 0x004d,
+	0x14b6: 0x004f, 0x14b7: 0x0051, 0x14b8: 0x0053, 0x14b9: 0x0055, 0x14ba: 0x0057, 0x14bb: 0x0059,
+	0x14bc: 0x005b, 0x14bd: 0x005d, 0x14be: 0x005f, 0x14bf: 0x0061,
+	// Block 0x53, offset 0x14c0
+	0x14c0: 0x26ad, 0x14c1: 0x26c2, 0x14c2: 0x0503,
+	0x14d0: 0x0c0f, 0x14d1: 0x0a47,
+	0x14d2: 0x08d3, 0x14d3: 0x45c4, 0x14d4: 0x071b, 0x14d5: 0x09ef, 0x14d6: 0x132f, 0x14d7: 0x09ff,
+	0x14d8: 0x0727, 0x14d9: 0x0cd7, 0x14da: 0x0eaf, 0x14db: 0x0caf, 0x14dc: 0x0827, 0x14dd: 0x0b6b,
+	0x14de: 0x07bf, 0x14df: 0x0cb7, 0x14e0: 0x0813, 0x14e1: 0x1117, 0x14e2: 0x0f83, 0x14e3: 0x138b,
+	0x14e4: 0x09d3, 0x14e5: 0x090b, 0x14e6: 0x0e63, 0x14e7: 0x0c1b, 0x14e8: 0x0c47, 0x14e9: 0x06bf,
+	0x14ea: 0x06cb, 0x14eb: 0x140b, 0x14ec: 0x0adb, 0x14ed: 0x06e7, 0x14ee: 0x08ef, 0x14ef: 0x0c3b,
+	0x14f0: 0x13b3, 0x14f1: 0x0c13, 0x14f2: 0x106f, 0x14f3: 0x10ab, 0x14f4: 0x08f7, 0x14f5: 0x0e43,
+	0x14f6: 0x0d0b, 0x14f7: 0x0d07, 0x14f8: 0x0f97, 0x14f9: 0x082b, 0x14fa: 0x0957, 0x14fb: 0x1443,
+	// Block 0x54, offset 0x1500
+	0x1500: 0x06fb, 0x1501: 0x06f3, 0x1502: 0x0703, 0x1503: 0x1647, 0x1504: 0x0747, 0x1505: 0x0757,
+	0x1506: 0x075b, 0x1507: 0x0763, 0x1508: 0x076b, 0x1509: 0x076f, 0x150a: 0x077b, 0x150b: 0x0773,
+	0x150c: 0x05b3, 0x150d: 0x165b, 0x150e: 0x078f, 0x150f: 0x0793, 0x1510: 0x0797, 0x1511: 0x07b3,
+	0x1512: 0x164c, 0x1513: 0x05b7, 0x1514: 0x079f, 0x1515: 0x07bf, 0x1516: 0x1656, 0x1517: 0x07cf,
+	0x1518: 0x07d7, 0x1519: 0x0737, 0x151a: 0x07df, 0x151b: 0x07e3, 0x151c: 0x1831, 0x151d: 0x07ff,
+	0x151e: 0x0807, 0x151f: 0x05bf, 0x1520: 0x081f, 0x1521: 0x0823, 0x1522: 0x082b, 0x1523: 0x082f,
+	0x1524: 0x05c3, 0x1525: 0x0847, 0x1526: 0x084b, 0x1527: 0x0857, 0x1528: 0x0863, 0x1529: 0x0867,
+	0x152a: 0x086b, 0x152b: 0x0873, 0x152c: 0x0893, 0x152d: 0x0897, 0x152e: 0x089f, 0x152f: 0x08af,
+	0x1530: 0x08b7, 0x1531: 0x08bb, 0x1532: 0x08bb, 0x1533: 0x08bb, 0x1534: 0x166a, 0x1535: 0x0e93,
+	0x1536: 0x08cf, 0x1537: 0x08d7, 0x1538: 0x166f, 0x1539: 0x08e3, 0x153a: 0x08eb, 0x153b: 0x08f3,
+	0x153c: 0x091b, 0x153d: 0x0907, 0x153e: 0x0913, 0x153f: 0x0917,
+	// Block 0x55, offset 0x1540
+	0x1540: 0x091f, 0x1541: 0x0927, 0x1542: 0x092b, 0x1543: 0x0933, 0x1544: 0x093b, 0x1545: 0x093f,
+	0x1546: 0x093f, 0x1547: 0x0947, 0x1548: 0x094f, 0x1549: 0x0953, 0x154a: 0x095f, 0x154b: 0x0983,
+	0x154c: 0x0967, 0x154d: 0x0987, 0x154e: 0x096b, 0x154f: 0x0973, 0x1550: 0x080b, 0x1551: 0x09cf,
+	0x1552: 0x0997, 0x1553: 0x099b, 0x1554: 0x099f, 0x1555: 0x0993, 0x1556: 0x09a7, 0x1557: 0x09a3,
+	0x1558: 0x09bb, 0x1559: 0x1674, 0x155a: 0x09d7, 0x155b: 0x09db, 0x155c: 0x09e3, 0x155d: 0x09ef,
+	0x155e: 0x09f7, 0x155f: 0x0a13, 0x1560: 0x1679, 0x1561: 0x167e, 0x1562: 0x0a1f, 0x1563: 0x0a23,
+	0x1564: 0x0a27, 0x1565: 0x0a1b, 0x1566: 0x0a2f, 0x1567: 0x05c7, 0x1568: 0x05cb, 0x1569: 0x0a37,
+	0x156a: 0x0a3f, 0x156b: 0x0a3f, 0x156c: 0x1683, 0x156d: 0x0a5b, 0x156e: 0x0a5f, 0x156f: 0x0a63,
+	0x1570: 0x0a6b, 0x1571: 0x1688, 0x1572: 0x0a73, 0x1573: 0x0a77, 0x1574: 0x0b4f, 0x1575: 0x0a7f,
+	0x1576: 0x05cf, 0x1577: 0x0a8b, 0x1578: 0x0a9b, 0x1579: 0x0aa7, 0x157a: 0x0aa3, 0x157b: 0x1692,
+	0x157c: 0x0aaf, 0x157d: 0x1697, 0x157e: 0x0abb, 0x157f: 0x0ab7,
+	// Block 0x56, offset 0x1580
+	0x1580: 0x0abf, 0x1581: 0x0acf, 0x1582: 0x0ad3, 0x1583: 0x05d3, 0x1584: 0x0ae3, 0x1585: 0x0aeb,
+	0x1586: 0x0aef, 0x1587: 0x0af3, 0x1588: 0x05d7, 0x1589: 0x169c, 0x158a: 0x05db, 0x158b: 0x0b0f,
+	0x158c: 0x0b13, 0x158d: 0x0b17, 0x158e: 0x0b1f, 0x158f: 0x1863, 0x1590: 0x0b37, 0x1591: 0x16a6,
+	0x1592: 0x16a6, 0x1593: 0x11d7, 0x1594: 0x0b47, 0x1595: 0x0b47, 0x1596: 0x05df, 0x1597: 0x16c9,
+	0x1598: 0x179b, 0x1599: 0x0b57, 0x159a: 0x0b5f, 0x159b: 0x05e3, 0x159c: 0x0b73, 0x159d: 0x0b83,
+	0x159e: 0x0b87, 0x159f: 0x0b8f, 0x15a0: 0x0b9f, 0x15a1: 0x05eb, 0x15a2: 0x05e7, 0x15a3: 0x0ba3,
+	0x15a4: 0x16ab, 0x15a5: 0x0ba7, 0x15a6: 0x0bbb, 0x15a7: 0x0bbf, 0x15a8: 0x0bc3, 0x15a9: 0x0bbf,
+	0x15aa: 0x0bcf, 0x15ab: 0x0bd3, 0x15ac: 0x0be3, 0x15ad: 0x0bdb, 0x15ae: 0x0bdf, 0x15af: 0x0be7,
+	0x15b0: 0x0beb, 0x15b1: 0x0bef, 0x15b2: 0x0bfb, 0x15b3: 0x0bff, 0x15b4: 0x0c17, 0x15b5: 0x0c1f,
+	0x15b6: 0x0c2f, 0x15b7: 0x0c43, 0x15b8: 0x16ba, 0x15b9: 0x0c3f, 0x15ba: 0x0c33, 0x15bb: 0x0c4b,
+	0x15bc: 0x0c53, 0x15bd: 0x0c67, 0x15be: 0x16bf, 0x15bf: 0x0c6f,
+	// Block 0x57, offset 0x15c0
+	0x15c0: 0x0c63, 0x15c1: 0x0c5b, 0x15c2: 0x05ef, 0x15c3: 0x0c77, 0x15c4: 0x0c7f, 0x15c5: 0x0c87,
+	0x15c6: 0x0c7b, 0x15c7: 0x05f3, 0x15c8: 0x0c97, 0x15c9: 0x0c9f, 0x15ca: 0x16c4, 0x15cb: 0x0ccb,
+	0x15cc: 0x0cff, 0x15cd: 0x0cdb, 0x15ce: 0x05ff, 0x15cf: 0x0ce7, 0x15d0: 0x05fb, 0x15d1: 0x05f7,
+	0x15d2: 0x07c3, 0x15d3: 0x07c7, 0x15d4: 0x0d03, 0x15d5: 0x0ceb, 0x15d6: 0x11ab, 0x15d7: 0x0663,
+	0x15d8: 0x0d0f, 0x15d9: 0x0d13, 0x15da: 0x0d17, 0x15db: 0x0d2b, 0x15dc: 0x0d23, 0x15dd: 0x16dd,
+	0x15de: 0x0603, 0x15df: 0x0d3f, 0x15e0: 0x0d33, 0x15e1: 0x0d4f, 0x15e2: 0x0d57, 0x15e3: 0x16e7,
+	0x15e4: 0x0d5b, 0x15e5: 0x0d47, 0x15e6: 0x0d63, 0x15e7: 0x0607, 0x15e8: 0x0d67, 0x15e9: 0x0d6b,
+	0x15ea: 0x0d6f, 0x15eb: 0x0d7b, 0x15ec: 0x16ec, 0x15ed: 0x0d83, 0x15ee: 0x060b, 0x15ef: 0x0d8f,
+	0x15f0: 0x16f1, 0x15f1: 0x0d93, 0x15f2: 0x060f, 0x15f3: 0x0d9f, 0x15f4: 0x0dab, 0x15f5: 0x0db7,
+	0x15f6: 0x0dbb, 0x15f7: 0x16f6, 0x15f8: 0x168d, 0x15f9: 0x16fb, 0x15fa: 0x0ddb, 0x15fb: 0x1700,
+	0x15fc: 0x0de7, 0x15fd: 0x0def, 0x15fe: 0x0ddf, 0x15ff: 0x0dfb,
+	// Block 0x58, offset 0x1600
+	0x1600: 0x0e0b, 0x1601: 0x0e1b, 0x1602: 0x0e0f, 0x1603: 0x0e13, 0x1604: 0x0e1f, 0x1605: 0x0e23,
+	0x1606: 0x1705, 0x1607: 0x0e07, 0x1608: 0x0e3b, 0x1609: 0x0e3f, 0x160a: 0x0613, 0x160b: 0x0e53,
+	0x160c: 0x0e4f, 0x160d: 0x170a, 0x160e: 0x0e33, 0x160f: 0x0e6f, 0x1610: 0x170f, 0x1611: 0x1714,
+	0x1612: 0x0e73, 0x1613: 0x0e87, 0x1614: 0x0e83, 0x1615: 0x0e7f, 0x1616: 0x0617, 0x1617: 0x0e8b,
+	0x1618: 0x0e9b, 0x1619: 0x0e97, 0x161a: 0x0ea3, 0x161b: 0x1651, 0x161c: 0x0eb3, 0x161d: 0x1719,
+	0x161e: 0x0ebf, 0x161f: 0x1723, 0x1620: 0x0ed3, 0x1621: 0x0edf, 0x1622: 0x0ef3, 0x1623: 0x1728,
+	0x1624: 0x0f07, 0x1625: 0x0f0b, 0x1626: 0x172d, 0x1627: 0x1732, 0x1628: 0x0f27, 0x1629: 0x0f37,
+	0x162a: 0x061b, 0x162b: 0x0f3b, 0x162c: 0x061f, 0x162d: 0x061f, 0x162e: 0x0f53, 0x162f: 0x0f57,
+	0x1630: 0x0f5f, 0x1631: 0x0f63, 0x1632: 0x0f6f, 0x1633: 0x0623, 0x1634: 0x0f87, 0x1635: 0x1737,
+	0x1636: 0x0fa3, 0x1637: 0x173c, 0x1638: 0x0faf, 0x1639: 0x16a1, 0x163a: 0x0fbf, 0x163b: 0x1741,
+	0x163c: 0x1746, 0x163d: 0x174b, 0x163e: 0x0627, 0x163f: 0x062b,
+	// Block 0x59, offset 0x1640
+	0x1640: 0x0ff7, 0x1641: 0x1755, 0x1642: 0x1750, 0x1643: 0x175a, 0x1644: 0x175f, 0x1645: 0x0fff,
+	0x1646: 0x1003, 0x1647: 0x1003, 0x1648: 0x100b, 0x1649: 0x0633, 0x164a: 0x100f, 0x164b: 0x0637,
+	0x164c: 0x063b, 0x164d: 0x1769, 0x164e: 0x1023, 0x164f: 0x102b, 0x1650: 0x1037, 0x1651: 0x063f,
+	0x1652: 0x176e, 0x1653: 0x105b, 0x1654: 0x1773, 0x1655: 0x1778, 0x1656: 0x107b, 0x1657: 0x1093,
+	0x1658: 0x0643, 0x1659: 0x109b, 0x165a: 0x109f, 0x165b: 0x10a3, 0x165c: 0x177d, 0x165d: 0x1782,
+	0x165e: 0x1782, 0x165f: 0x10bb, 0x1660: 0x0647, 0x1661: 0x1787, 0x1662: 0x10cf, 0x1663: 0x10d3,
+	0x1664: 0x064b, 0x1665: 0x178c, 0x1666: 0x10ef, 0x1667: 0x064f, 0x1668: 0x10ff, 0x1669: 0x10f7,
+	0x166a: 0x1107, 0x166b: 0x1796, 0x166c: 0x111f, 0x166d: 0x0653, 0x166e: 0x112b, 0x166f: 0x1133,
+	0x1670: 0x1143, 0x1671: 0x0657, 0x1672: 0x17a0, 0x1673: 0x17a5, 0x1674: 0x065b, 0x1675: 0x17aa,
+	0x1676: 0x115b, 0x1677: 0x17af, 0x1678: 0x1167, 0x1679: 0x1173, 0x167a: 0x117b, 0x167b: 0x17b4,
+	0x167c: 0x17b9, 0x167d: 0x118f, 0x167e: 0x17be, 0x167f: 0x1197,
+	// Block 0x5a, offset 0x1680
+	0x1680: 0x16ce, 0x1681: 0x065f, 0x1682: 0x11af, 0x1683: 0x11b3, 0x1684: 0x0667, 0x1685: 0x11b7,
+	0x1686: 0x0a33, 0x1687: 0x17c3, 0x1688: 0x17c8, 0x1689: 0x16d3, 0x168a: 0x16d8, 0x168b: 0x11d7,
+	0x168c: 0x11db, 0x168d: 0x13f3, 0x168e: 0x066b, 0x168f: 0x1207, 0x1690: 0x1203, 0x1691: 0x120b,
+	0x1692: 0x083f, 0x1693: 0x120f, 0x1694: 0x1213, 0x1695: 0x1217, 0x1696: 0x121f, 0x1697: 0x17cd,
+	0x1698: 0x121b, 0x1699: 0x1223, 0x169a: 0x1237, 0x169b: 0x123b, 0x169c: 0x1227, 0x169d: 0x123f,
+	0x169e: 0x1253, 0x169f: 0x1267, 0x16a0: 0x1233, 0x16a1: 0x1247, 0x16a2: 0x124b, 0x16a3: 0x124f,
+	0x16a4: 0x17d2, 0x16a5: 0x17dc, 0x16a6: 0x17d7, 0x16a7: 0x066f, 0x16a8: 0x126f, 0x16a9: 0x1273,
+	0x16aa: 0x127b, 0x16ab: 0x17f0, 0x16ac: 0x127f, 0x16ad: 0x17e1, 0x16ae: 0x0673, 0x16af: 0x0677,
+	0x16b0: 0x17e6, 0x16b1: 0x17eb, 0x16b2: 0x067b, 0x16b3: 0x129f, 0x16b4: 0x12a3, 0x16b5: 0x12a7,
+	0x16b6: 0x12ab, 0x16b7: 0x12b7, 0x16b8: 0x12b3, 0x16b9: 0x12bf, 0x16ba: 0x12bb, 0x16bb: 0x12cb,
+	0x16bc: 0x12c3, 0x16bd: 0x12c7, 0x16be: 0x12cf, 0x16bf: 0x067f,
+	// Block 0x5b, offset 0x16c0
+	0x16c0: 0x12d7, 0x16c1: 0x12db, 0x16c2: 0x0683, 0x16c3: 0x12eb, 0x16c4: 0x12ef, 0x16c5: 0x17f5,
+	0x16c6: 0x12fb, 0x16c7: 0x12ff, 0x16c8: 0x0687, 0x16c9: 0x130b, 0x16ca: 0x05bb, 0x16cb: 0x17fa,
+	0x16cc: 0x17ff, 0x16cd: 0x068b, 0x16ce: 0x068f, 0x16cf: 0x1337, 0x16d0: 0x134f, 0x16d1: 0x136b,
+	0x16d2: 0x137b, 0x16d3: 0x1804, 0x16d4: 0x138f, 0x16d5: 0x1393, 0x16d6: 0x13ab, 0x16d7: 0x13b7,
+	0x16d8: 0x180e, 0x16d9: 0x1660, 0x16da: 0x13c3, 0x16db: 0x13bf, 0x16dc: 0x13cb, 0x16dd: 0x1665,
+	0x16de: 0x13d7, 0x16df: 0x13e3, 0x16e0: 0x1813, 0x16e1: 0x1818, 0x16e2: 0x1423, 0x16e3: 0x142f,
+	0x16e4: 0x1437, 0x16e5: 0x181d, 0x16e6: 0x143b, 0x16e7: 0x1467, 0x16e8: 0x1473, 0x16e9: 0x1477,
+	0x16ea: 0x146f, 0x16eb: 0x1483, 0x16ec: 0x1487, 0x16ed: 0x1822, 0x16ee: 0x1493, 0x16ef: 0x0693,
+	0x16f0: 0x149b, 0x16f1: 0x1827, 0x16f2: 0x0697, 0x16f3: 0x14d3, 0x16f4: 0x0ac3, 0x16f5: 0x14eb,
+	0x16f6: 0x182c, 0x16f7: 0x1836, 0x16f8: 0x069b, 0x16f9: 0x069f, 0x16fa: 0x1513, 0x16fb: 0x183b,
+	0x16fc: 0x06a3, 0x16fd: 0x1840, 0x16fe: 0x152b, 0x16ff: 0x152b,
+	// Block 0x5c, offset 0x1700
+	0x1700: 0x1533, 0x1701: 0x1845, 0x1702: 0x154b, 0x1703: 0x06a7, 0x1704: 0x155b, 0x1705: 0x1567,
+	0x1706: 0x156f, 0x1707: 0x1577, 0x1708: 0x06ab, 0x1709: 0x184a, 0x170a: 0x158b, 0x170b: 0x15a7,
+	0x170c: 0x15b3, 0x170d: 0x06af, 0x170e: 0x06b3, 0x170f: 0x15b7, 0x1710: 0x184f, 0x1711: 0x06b7,
+	0x1712: 0x1854, 0x1713: 0x1859, 0x1714: 0x185e, 0x1715: 0x15db, 0x1716: 0x06bb, 0x1717: 0x15ef,
+	0x1718: 0x15f7, 0x1719: 0x15fb, 0x171a: 0x1603, 0x171b: 0x160b, 0x171c: 0x1613, 0x171d: 0x1868,
+}
+
+// nfkcIndex: 22 blocks, 1408 entries, 1408 bytes
+// Block 0 is the zero block.
+var nfkcIndex = [1408]uint8{
+	// Block 0x0, offset 0x0
+	// Block 0x1, offset 0x40
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc2: 0x5b, 0xc3: 0x01, 0xc4: 0x02, 0xc5: 0x03, 0xc6: 0x5c, 0xc7: 0x04,
+	0xc8: 0x05, 0xca: 0x5d, 0xcb: 0x5e, 0xcc: 0x06, 0xcd: 0x07, 0xce: 0x08, 0xcf: 0x09,
+	0xd0: 0x0a, 0xd1: 0x5f, 0xd2: 0x60, 0xd3: 0x0b, 0xd6: 0x0c, 0xd7: 0x61,
+	0xd8: 0x62, 0xd9: 0x0d, 0xdb: 0x63, 0xdc: 0x64, 0xdd: 0x65, 0xdf: 0x66,
+	0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05,
+	0xea: 0x06, 0xeb: 0x07, 0xec: 0x08, 0xed: 0x09, 0xef: 0x0a,
+	0xf0: 0x13,
+	// Block 0x4, offset 0x100
+	0x120: 0x67, 0x121: 0x68, 0x123: 0x69, 0x124: 0x6a, 0x125: 0x6b, 0x126: 0x6c, 0x127: 0x6d,
+	0x128: 0x6e, 0x129: 0x6f, 0x12a: 0x70, 0x12b: 0x71, 0x12c: 0x6c, 0x12d: 0x72, 0x12e: 0x73, 0x12f: 0x74,
+	0x131: 0x75, 0x132: 0x76, 0x133: 0x77, 0x134: 0x78, 0x135: 0x79, 0x137: 0x7a,
+	0x138: 0x7b, 0x139: 0x7c, 0x13a: 0x7d, 0x13b: 0x7e, 0x13c: 0x7f, 0x13d: 0x80, 0x13e: 0x81, 0x13f: 0x82,
+	// Block 0x5, offset 0x140
+	0x140: 0x83, 0x142: 0x84, 0x143: 0x85, 0x144: 0x86, 0x145: 0x87, 0x146: 0x88, 0x147: 0x89,
+	0x14d: 0x8a,
+	0x15c: 0x8b, 0x15f: 0x8c,
+	0x162: 0x8d, 0x164: 0x8e,
+	0x168: 0x8f, 0x169: 0x90, 0x16a: 0x91, 0x16c: 0x0e, 0x16d: 0x92, 0x16e: 0x93, 0x16f: 0x94,
+	0x170: 0x95, 0x173: 0x96, 0x174: 0x97, 0x175: 0x0f, 0x176: 0x10, 0x177: 0x11,
+	0x178: 0x12, 0x179: 0x13, 0x17a: 0x14, 0x17b: 0x15, 0x17c: 0x16, 0x17d: 0x17, 0x17e: 0x18, 0x17f: 0x19,
+	// Block 0x6, offset 0x180
+	0x180: 0x98, 0x181: 0x99, 0x182: 0x9a, 0x183: 0x9b, 0x184: 0x1a, 0x185: 0x1b, 0x186: 0x9c, 0x187: 0x9d,
+	0x188: 0x9e, 0x189: 0x1c, 0x18a: 0x1d, 0x18b: 0x9f, 0x18c: 0xa0,
+	0x191: 0x1e, 0x192: 0x1f, 0x193: 0xa1,
+	0x1a8: 0xa2, 0x1a9: 0xa3, 0x1ab: 0xa4,
+	0x1b1: 0xa5, 0x1b3: 0xa6, 0x1b5: 0xa7, 0x1b7: 0xa8,
+	0x1ba: 0xa9, 0x1bb: 0xaa, 0x1bc: 0x20, 0x1bd: 0x21, 0x1be: 0x22, 0x1bf: 0xab,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0xac, 0x1c1: 0x23, 0x1c2: 0x24, 0x1c3: 0x25, 0x1c4: 0xad, 0x1c5: 0x26, 0x1c6: 0x27,
+	0x1c8: 0x28, 0x1c9: 0x29, 0x1ca: 0x2a, 0x1cb: 0x2b, 0x1cc: 0x2c, 0x1cd: 0x2d, 0x1ce: 0x2e, 0x1cf: 0x2f,
+	// Block 0x8, offset 0x200
+	0x219: 0xae, 0x21a: 0xaf, 0x21b: 0xb0, 0x21d: 0xb1, 0x21f: 0xb2,
+	0x220: 0xb3, 0x223: 0xb4, 0x224: 0xb5, 0x225: 0xb6, 0x226: 0xb7, 0x227: 0xb8,
+	0x22a: 0xb9, 0x22b: 0xba, 0x22d: 0xbb, 0x22f: 0xbc,
+	0x230: 0xbd, 0x231: 0xbe, 0x232: 0xbf, 0x233: 0xc0, 0x234: 0xc1, 0x235: 0xc2, 0x236: 0xc3, 0x237: 0xbd,
+	0x238: 0xbe, 0x239: 0xbf, 0x23a: 0xc0, 0x23b: 0xc1, 0x23c: 0xc2, 0x23d: 0xc3, 0x23e: 0xbd, 0x23f: 0xbe,
+	// Block 0x9, offset 0x240
+	0x240: 0xbf, 0x241: 0xc0, 0x242: 0xc1, 0x243: 0xc2, 0x244: 0xc3, 0x245: 0xbd, 0x246: 0xbe, 0x247: 0xbf,
+	0x248: 0xc0, 0x249: 0xc1, 0x24a: 0xc2, 0x24b: 0xc3, 0x24c: 0xbd, 0x24d: 0xbe, 0x24e: 0xbf, 0x24f: 0xc0,
+	0x250: 0xc1, 0x251: 0xc2, 0x252: 0xc3, 0x253: 0xbd, 0x254: 0xbe, 0x255: 0xbf, 0x256: 0xc0, 0x257: 0xc1,
+	0x258: 0xc2, 0x259: 0xc3, 0x25a: 0xbd, 0x25b: 0xbe, 0x25c: 0xbf, 0x25d: 0xc0, 0x25e: 0xc1, 0x25f: 0xc2,
+	0x260: 0xc3, 0x261: 0xbd, 0x262: 0xbe, 0x263: 0xbf, 0x264: 0xc0, 0x265: 0xc1, 0x266: 0xc2, 0x267: 0xc3,
+	0x268: 0xbd, 0x269: 0xbe, 0x26a: 0xbf, 0x26b: 0xc0, 0x26c: 0xc1, 0x26d: 0xc2, 0x26e: 0xc3, 0x26f: 0xbd,
+	0x270: 0xbe, 0x271: 0xbf, 0x272: 0xc0, 0x273: 0xc1, 0x274: 0xc2, 0x275: 0xc3, 0x276: 0xbd, 0x277: 0xbe,
+	0x278: 0xbf, 0x279: 0xc0, 0x27a: 0xc1, 0x27b: 0xc2, 0x27c: 0xc3, 0x27d: 0xbd, 0x27e: 0xbe, 0x27f: 0xbf,
+	// Block 0xa, offset 0x280
+	0x280: 0xc0, 0x281: 0xc1, 0x282: 0xc2, 0x283: 0xc3, 0x284: 0xbd, 0x285: 0xbe, 0x286: 0xbf, 0x287: 0xc0,
+	0x288: 0xc1, 0x289: 0xc2, 0x28a: 0xc3, 0x28b: 0xbd, 0x28c: 0xbe, 0x28d: 0xbf, 0x28e: 0xc0, 0x28f: 0xc1,
+	0x290: 0xc2, 0x291: 0xc3, 0x292: 0xbd, 0x293: 0xbe, 0x294: 0xbf, 0x295: 0xc0, 0x296: 0xc1, 0x297: 0xc2,
+	0x298: 0xc3, 0x299: 0xbd, 0x29a: 0xbe, 0x29b: 0xbf, 0x29c: 0xc0, 0x29d: 0xc1, 0x29e: 0xc2, 0x29f: 0xc3,
+	0x2a0: 0xbd, 0x2a1: 0xbe, 0x2a2: 0xbf, 0x2a3: 0xc0, 0x2a4: 0xc1, 0x2a5: 0xc2, 0x2a6: 0xc3, 0x2a7: 0xbd,
+	0x2a8: 0xbe, 0x2a9: 0xbf, 0x2aa: 0xc0, 0x2ab: 0xc1, 0x2ac: 0xc2, 0x2ad: 0xc3, 0x2ae: 0xbd, 0x2af: 0xbe,
+	0x2b0: 0xbf, 0x2b1: 0xc0, 0x2b2: 0xc1, 0x2b3: 0xc2, 0x2b4: 0xc3, 0x2b5: 0xbd, 0x2b6: 0xbe, 0x2b7: 0xbf,
+	0x2b8: 0xc0, 0x2b9: 0xc1, 0x2ba: 0xc2, 0x2bb: 0xc3, 0x2bc: 0xbd, 0x2bd: 0xbe, 0x2be: 0xbf, 0x2bf: 0xc0,
+	// Block 0xb, offset 0x2c0
+	0x2c0: 0xc1, 0x2c1: 0xc2, 0x2c2: 0xc3, 0x2c3: 0xbd, 0x2c4: 0xbe, 0x2c5: 0xbf, 0x2c6: 0xc0, 0x2c7: 0xc1,
+	0x2c8: 0xc2, 0x2c9: 0xc3, 0x2ca: 0xbd, 0x2cb: 0xbe, 0x2cc: 0xbf, 0x2cd: 0xc0, 0x2ce: 0xc1, 0x2cf: 0xc2,
+	0x2d0: 0xc3, 0x2d1: 0xbd, 0x2d2: 0xbe, 0x2d3: 0xbf, 0x2d4: 0xc0, 0x2d5: 0xc1, 0x2d6: 0xc2, 0x2d7: 0xc3,
+	0x2d8: 0xbd, 0x2d9: 0xbe, 0x2da: 0xbf, 0x2db: 0xc0, 0x2dc: 0xc1, 0x2dd: 0xc2, 0x2de: 0xc4,
+	// Block 0xc, offset 0x300
+	0x324: 0x30, 0x325: 0x31, 0x326: 0x32, 0x327: 0x33,
+	0x328: 0x34, 0x329: 0x35, 0x32a: 0x36, 0x32b: 0x37, 0x32c: 0x38, 0x32d: 0x39, 0x32e: 0x3a, 0x32f: 0x3b,
+	0x330: 0x3c, 0x331: 0x3d, 0x332: 0x3e, 0x333: 0x3f, 0x334: 0x40, 0x335: 0x41, 0x336: 0x42, 0x337: 0x43,
+	0x338: 0x44, 0x339: 0x45, 0x33a: 0x46, 0x33b: 0x47, 0x33c: 0xc5, 0x33d: 0x48, 0x33e: 0x49, 0x33f: 0x4a,
+	// Block 0xd, offset 0x340
+	0x347: 0xc6,
+	0x34b: 0xc7, 0x34d: 0xc8,
+	0x368: 0xc9, 0x36b: 0xca,
+	// Block 0xe, offset 0x380
+	0x381: 0xcb, 0x382: 0xcc, 0x384: 0xcd, 0x385: 0xb7, 0x387: 0xce,
+	0x388: 0xcf, 0x38b: 0xd0, 0x38c: 0x6c, 0x38d: 0xd1,
+	0x391: 0xd2, 0x392: 0xd3, 0x393: 0xd4, 0x396: 0xd5, 0x397: 0xd6,
+	0x398: 0xd7, 0x39a: 0xd8, 0x39c: 0xd9,
+	0x3a8: 0xda, 0x3a9: 0xdb, 0x3aa: 0xdc,
+	0x3b0: 0xd7, 0x3b5: 0xdd,
+	// Block 0xf, offset 0x3c0
+	0x3eb: 0xde, 0x3ec: 0xdf,
+	// Block 0x10, offset 0x400
+	0x432: 0xe0,
+	// Block 0x11, offset 0x440
+	0x445: 0xe1, 0x446: 0xe2, 0x447: 0xe3,
+	0x449: 0xe4,
+	0x450: 0xe5, 0x451: 0xe6, 0x452: 0xe7, 0x453: 0xe8, 0x454: 0xe9, 0x455: 0xea, 0x456: 0xeb, 0x457: 0xec,
+	0x458: 0xed, 0x459: 0xee, 0x45a: 0x4b, 0x45b: 0xef, 0x45c: 0xf0, 0x45d: 0xf1, 0x45e: 0xf2, 0x45f: 0x4c,
+	// Block 0x12, offset 0x480
+	0x480: 0xf3,
+	0x4a3: 0xf4, 0x4a5: 0xf5,
+	0x4b8: 0x4d, 0x4b9: 0x4e, 0x4ba: 0x4f,
+	// Block 0x13, offset 0x4c0
+	0x4c4: 0x50, 0x4c5: 0xf6, 0x4c6: 0xf7,
+	0x4c8: 0x51, 0x4c9: 0xf8,
+	// Block 0x14, offset 0x500
+	0x520: 0x52, 0x521: 0x53, 0x522: 0x54, 0x523: 0x55, 0x524: 0x56, 0x525: 0x57, 0x526: 0x58, 0x527: 0x59,
+	0x528: 0x5a,
+	// Block 0x15, offset 0x540
+	0x550: 0x0b, 0x551: 0x0c, 0x556: 0x0d,
+	0x55b: 0x0e, 0x55d: 0x0f, 0x55e: 0x10, 0x55f: 0x11,
+	0x56f: 0x12,
+}
+
+// nfkcSparseOffset: 158 entries, 316 bytes
+var nfkcSparseOffset = []uint16{0x0, 0xe, 0x12, 0x1b, 0x25, 0x35, 0x37, 0x3c, 0x47, 0x56, 0x63, 0x6b, 0x6f, 0x74, 0x76, 0x87, 0x8f, 0x96, 0x99, 0xa0, 0xa4, 0xa8, 0xaa, 0xac, 0xb5, 0xb9, 0xc0, 0xc5, 0xc8, 0xd2, 0xd5, 0xdc, 0xe4, 0xe8, 0xea, 0xed, 0xf1, 0xf7, 0x108, 0x114, 0x116, 0x11c, 0x11e, 0x120, 0x122, 0x124, 0x126, 0x128, 0x12a, 0x12d, 0x130, 0x132, 0x135, 0x138, 0x13c, 0x141, 0x14a, 0x14c, 0x14f, 0x151, 0x15c, 0x167, 0x175, 0x183, 0x193, 0x1a1, 0x1a8, 0x1ae, 0x1bd, 0x1c1, 0x1c3, 0x1c7, 0x1c9, 0x1cc, 0x1ce, 0x1d1, 0x1d3, 0x1d6, 0x1d8, 0x1da, 0x1dc, 0x1e8, 0x1f2, 0x1fc, 0x1ff, 0x203, 0x205, 0x207, 0x209, 0x20b, 0x20e, 0x210, 0x212, 0x214, 0x216, 0x21c, 0x21f, 0x223, 0x225, 0x22c, 0x232, 0x238, 0x240, 0x246, 0x24c, 0x252, 0x256, 0x258, 0x25a, 0x25c, 0x25e, 0x264, 0x267, 0x26a, 0x272, 0x279, 0x27c, 0x27f, 0x281, 0x289, 0x28c, 0x293, 0x296, 0x29c, 0x29e, 0x2a0, 0x2a3, 0x2a5, 0x2a7, 0x2a9, 0x2ab, 0x2ae, 0x2b0, 0x2b2, 0x2b4, 0x2c1, 0x2cb, 0x2cd, 0x2cf, 0x2d3, 0x2d8, 0x2e4, 0x2e9, 0x2f2, 0x2f8, 0x2fd, 0x301, 0x306, 0x30a, 0x31a, 0x328, 0x336, 0x344, 0x34a, 0x34c, 0x34f, 0x359, 0x35b}
+
+// nfkcSparseValues: 869 entries, 3476 bytes
+var nfkcSparseValues = [869]valueRange{
+	// Block 0x0, offset 0x0
+	{value: 0x0002, lo: 0x0d},
+	{value: 0x0001, lo: 0xa0, hi: 0xa0},
+	{value: 0x4278, lo: 0xa8, hi: 0xa8},
+	{value: 0x0083, lo: 0xaa, hi: 0xaa},
+	{value: 0x4264, lo: 0xaf, hi: 0xaf},
+	{value: 0x0025, lo: 0xb2, hi: 0xb3},
+	{value: 0x425a, lo: 0xb4, hi: 0xb4},
+	{value: 0x01dc, lo: 0xb5, hi: 0xb5},
+	{value: 0x4291, lo: 0xb8, hi: 0xb8},
+	{value: 0x0023, lo: 0xb9, hi: 0xb9},
+	{value: 0x009f, lo: 0xba, hi: 0xba},
+	{value: 0x221c, lo: 0xbc, hi: 0xbc},
+	{value: 0x2210, lo: 0xbd, hi: 0xbd},
+	{value: 0x22b2, lo: 0xbe, hi: 0xbe},
+	// Block 0x1, offset 0xe
+	{value: 0x0091, lo: 0x03},
+	{value: 0x46e2, lo: 0xa0, hi: 0xa1},
+	{value: 0x4714, lo: 0xaf, hi: 0xb0},
+	{value: 0xa000, lo: 0xb7, hi: 0xb7},
+	// Block 0x2, offset 0x12
+	{value: 0x0003, lo: 0x08},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x0091, lo: 0xb0, hi: 0xb0},
+	{value: 0x0119, lo: 0xb1, hi: 0xb1},
+	{value: 0x0095, lo: 0xb2, hi: 0xb2},
+	{value: 0x00a5, lo: 0xb3, hi: 0xb3},
+	{value: 0x0143, lo: 0xb4, hi: 0xb6},
+	{value: 0x00af, lo: 0xb7, hi: 0xb7},
+	{value: 0x00b3, lo: 0xb8, hi: 0xb8},
+	// Block 0x3, offset 0x1b
+	{value: 0x000a, lo: 0x09},
+	{value: 0x426e, lo: 0x98, hi: 0x98},
+	{value: 0x4273, lo: 0x99, hi: 0x9a},
+	{value: 0x4296, lo: 0x9b, hi: 0x9b},
+	{value: 0x425f, lo: 0x9c, hi: 0x9c},
+	{value: 0x4282, lo: 0x9d, hi: 0x9d},
+	{value: 0x0113, lo: 0xa0, hi: 0xa0},
+	{value: 0x0099, lo: 0xa1, hi: 0xa1},
+	{value: 0x00a7, lo: 0xa2, hi: 0xa3},
+	{value: 0x0167, lo: 0xa4, hi: 0xa4},
+	// Block 0x4, offset 0x25
+	{value: 0x0000, lo: 0x0f},
+	{value: 0xa000, lo: 0x83, hi: 0x83},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0xa000, lo: 0x8b, hi: 0x8b},
+	{value: 0xa000, lo: 0x8d, hi: 0x8d},
+	{value: 0x37a5, lo: 0x90, hi: 0x90},
+	{value: 0x37b1, lo: 0x91, hi: 0x91},
+	{value: 0x379f, lo: 0x93, hi: 0x93},
+	{value: 0xa000, lo: 0x96, hi: 0x96},
+	{value: 0x3817, lo: 0x97, hi: 0x97},
+	{value: 0x37e1, lo: 0x9c, hi: 0x9c},
+	{value: 0x37c9, lo: 0x9d, hi: 0x9d},
+	{value: 0x37f3, lo: 0x9e, hi: 0x9e},
+	{value: 0xa000, lo: 0xb4, hi: 0xb5},
+	{value: 0x381d, lo: 0xb6, hi: 0xb6},
+	{value: 0x3823, lo: 0xb7, hi: 0xb7},
+	// Block 0x5, offset 0x35
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x83, hi: 0x87},
+	// Block 0x6, offset 0x37
+	{value: 0x0001, lo: 0x04},
+	{value: 0x8113, lo: 0x81, hi: 0x82},
+	{value: 0x8132, lo: 0x84, hi: 0x84},
+	{value: 0x812d, lo: 0x85, hi: 0x85},
+	{value: 0x810d, lo: 0x87, hi: 0x87},
+	// Block 0x7, offset 0x3c
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x8132, lo: 0x90, hi: 0x97},
+	{value: 0x8119, lo: 0x98, hi: 0x98},
+	{value: 0x811a, lo: 0x99, hi: 0x99},
+	{value: 0x811b, lo: 0x9a, hi: 0x9a},
+	{value: 0x3841, lo: 0xa2, hi: 0xa2},
+	{value: 0x3847, lo: 0xa3, hi: 0xa3},
+	{value: 0x3853, lo: 0xa4, hi: 0xa4},
+	{value: 0x384d, lo: 0xa5, hi: 0xa5},
+	{value: 0x3859, lo: 0xa6, hi: 0xa6},
+	{value: 0xa000, lo: 0xa7, hi: 0xa7},
+	// Block 0x8, offset 0x47
+	{value: 0x0000, lo: 0x0e},
+	{value: 0x386b, lo: 0x80, hi: 0x80},
+	{value: 0xa000, lo: 0x81, hi: 0x81},
+	{value: 0x385f, lo: 0x82, hi: 0x82},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x3865, lo: 0x93, hi: 0x93},
+	{value: 0xa000, lo: 0x95, hi: 0x95},
+	{value: 0x8132, lo: 0x96, hi: 0x9c},
+	{value: 0x8132, lo: 0x9f, hi: 0xa2},
+	{value: 0x812d, lo: 0xa3, hi: 0xa3},
+	{value: 0x8132, lo: 0xa4, hi: 0xa4},
+	{value: 0x8132, lo: 0xa7, hi: 0xa8},
+	{value: 0x812d, lo: 0xaa, hi: 0xaa},
+	{value: 0x8132, lo: 0xab, hi: 0xac},
+	{value: 0x812d, lo: 0xad, hi: 0xad},
+	// Block 0x9, offset 0x56
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x811f, lo: 0x91, hi: 0x91},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	{value: 0x812d, lo: 0xb1, hi: 0xb1},
+	{value: 0x8132, lo: 0xb2, hi: 0xb3},
+	{value: 0x812d, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb5, hi: 0xb6},
+	{value: 0x812d, lo: 0xb7, hi: 0xb9},
+	{value: 0x8132, lo: 0xba, hi: 0xba},
+	{value: 0x812d, lo: 0xbb, hi: 0xbc},
+	{value: 0x8132, lo: 0xbd, hi: 0xbd},
+	{value: 0x812d, lo: 0xbe, hi: 0xbe},
+	{value: 0x8132, lo: 0xbf, hi: 0xbf},
+	// Block 0xa, offset 0x63
+	{value: 0x0005, lo: 0x07},
+	{value: 0x8132, lo: 0x80, hi: 0x80},
+	{value: 0x8132, lo: 0x81, hi: 0x81},
+	{value: 0x812d, lo: 0x82, hi: 0x83},
+	{value: 0x812d, lo: 0x84, hi: 0x85},
+	{value: 0x812d, lo: 0x86, hi: 0x87},
+	{value: 0x812d, lo: 0x88, hi: 0x89},
+	{value: 0x8132, lo: 0x8a, hi: 0x8a},
+	// Block 0xb, offset 0x6b
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8132, lo: 0xab, hi: 0xb1},
+	{value: 0x812d, lo: 0xb2, hi: 0xb2},
+	{value: 0x8132, lo: 0xb3, hi: 0xb3},
+	// Block 0xc, offset 0x6f
+	{value: 0x0000, lo: 0x04},
+	{value: 0x8132, lo: 0x96, hi: 0x99},
+	{value: 0x8132, lo: 0x9b, hi: 0xa3},
+	{value: 0x8132, lo: 0xa5, hi: 0xa7},
+	{value: 0x8132, lo: 0xa9, hi: 0xad},
+	// Block 0xd, offset 0x74
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x99, hi: 0x9b},
+	// Block 0xe, offset 0x76
+	{value: 0x0000, lo: 0x10},
+	{value: 0x8132, lo: 0x94, hi: 0xa1},
+	{value: 0x812d, lo: 0xa3, hi: 0xa3},
+	{value: 0x8132, lo: 0xa4, hi: 0xa5},
+	{value: 0x812d, lo: 0xa6, hi: 0xa6},
+	{value: 0x8132, lo: 0xa7, hi: 0xa8},
+	{value: 0x812d, lo: 0xa9, hi: 0xa9},
+	{value: 0x8132, lo: 0xaa, hi: 0xac},
+	{value: 0x812d, lo: 0xad, hi: 0xaf},
+	{value: 0x8116, lo: 0xb0, hi: 0xb0},
+	{value: 0x8117, lo: 0xb1, hi: 0xb1},
+	{value: 0x8118, lo: 0xb2, hi: 0xb2},
+	{value: 0x8132, lo: 0xb3, hi: 0xb5},
+	{value: 0x812d, lo: 0xb6, hi: 0xb6},
+	{value: 0x8132, lo: 0xb7, hi: 0xb8},
+	{value: 0x812d, lo: 0xb9, hi: 0xba},
+	{value: 0x8132, lo: 0xbb, hi: 0xbf},
+	// Block 0xf, offset 0x87
+	{value: 0x0000, lo: 0x07},
+	{value: 0xa000, lo: 0xa8, hi: 0xa8},
+	{value: 0x3ed8, lo: 0xa9, hi: 0xa9},
+	{value: 0xa000, lo: 0xb0, hi: 0xb0},
+	{value: 0x3ee0, lo: 0xb1, hi: 0xb1},
+	{value: 0xa000, lo: 0xb3, hi: 0xb3},
+	{value: 0x3ee8, lo: 0xb4, hi: 0xb4},
+	{value: 0x9902, lo: 0xbc, hi: 0xbc},
+	// Block 0x10, offset 0x8f
+	{value: 0x0008, lo: 0x06},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x8132, lo: 0x91, hi: 0x91},
+	{value: 0x812d, lo: 0x92, hi: 0x92},
+	{value: 0x8132, lo: 0x93, hi: 0x93},
+	{value: 0x8132, lo: 0x94, hi: 0x94},
+	{value: 0x451c, lo: 0x98, hi: 0x9f},
+	// Block 0x11, offset 0x96
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x12, offset 0x99
+	{value: 0x0008, lo: 0x06},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2c9e, lo: 0x8b, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	{value: 0x455c, lo: 0x9c, hi: 0x9d},
+	{value: 0x456c, lo: 0x9f, hi: 0x9f},
+	// Block 0x13, offset 0xa0
+	{value: 0x0000, lo: 0x03},
+	{value: 0x4594, lo: 0xb3, hi: 0xb3},
+	{value: 0x459c, lo: 0xb6, hi: 0xb6},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	// Block 0x14, offset 0xa4
+	{value: 0x0008, lo: 0x03},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x4574, lo: 0x99, hi: 0x9b},
+	{value: 0x458c, lo: 0x9e, hi: 0x9e},
+	// Block 0x15, offset 0xa8
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	// Block 0x16, offset 0xaa
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	// Block 0x17, offset 0xac
+	{value: 0x0000, lo: 0x08},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2cb6, lo: 0x88, hi: 0x88},
+	{value: 0x2cae, lo: 0x8b, hi: 0x8b},
+	{value: 0x2cbe, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x96, hi: 0x97},
+	{value: 0x45a4, lo: 0x9c, hi: 0x9c},
+	{value: 0x45ac, lo: 0x9d, hi: 0x9d},
+	// Block 0x18, offset 0xb5
+	{value: 0x0000, lo: 0x03},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0x2cc6, lo: 0x94, hi: 0x94},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x19, offset 0xb9
+	{value: 0x0000, lo: 0x06},
+	{value: 0xa000, lo: 0x86, hi: 0x87},
+	{value: 0x2cce, lo: 0x8a, hi: 0x8a},
+	{value: 0x2cde, lo: 0x8b, hi: 0x8b},
+	{value: 0x2cd6, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	// Block 0x1a, offset 0xc0
+	{value: 0x1801, lo: 0x04},
+	{value: 0xa000, lo: 0x86, hi: 0x86},
+	{value: 0x3ef0, lo: 0x88, hi: 0x88},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x8120, lo: 0x95, hi: 0x96},
+	// Block 0x1b, offset 0xc5
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xbc, hi: 0xbc},
+	{value: 0xa000, lo: 0xbf, hi: 0xbf},
+	// Block 0x1c, offset 0xc8
+	{value: 0x0000, lo: 0x09},
+	{value: 0x2ce6, lo: 0x80, hi: 0x80},
+	{value: 0x9900, lo: 0x82, hi: 0x82},
+	{value: 0xa000, lo: 0x86, hi: 0x86},
+	{value: 0x2cee, lo: 0x87, hi: 0x87},
+	{value: 0x2cf6, lo: 0x88, hi: 0x88},
+	{value: 0x2f50, lo: 0x8a, hi: 0x8a},
+	{value: 0x2dd8, lo: 0x8b, hi: 0x8b},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x95, hi: 0x96},
+	// Block 0x1d, offset 0xd2
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xbb, hi: 0xbc},
+	{value: 0x9900, lo: 0xbe, hi: 0xbe},
+	// Block 0x1e, offset 0xd5
+	{value: 0x0000, lo: 0x06},
+	{value: 0xa000, lo: 0x86, hi: 0x87},
+	{value: 0x2cfe, lo: 0x8a, hi: 0x8a},
+	{value: 0x2d0e, lo: 0x8b, hi: 0x8b},
+	{value: 0x2d06, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	// Block 0x1f, offset 0xdc
+	{value: 0x6bea, lo: 0x07},
+	{value: 0x9904, lo: 0x8a, hi: 0x8a},
+	{value: 0x9900, lo: 0x8f, hi: 0x8f},
+	{value: 0xa000, lo: 0x99, hi: 0x99},
+	{value: 0x3ef8, lo: 0x9a, hi: 0x9a},
+	{value: 0x2f58, lo: 0x9c, hi: 0x9c},
+	{value: 0x2de3, lo: 0x9d, hi: 0x9d},
+	{value: 0x2d16, lo: 0x9e, hi: 0x9f},
+	// Block 0x20, offset 0xe4
+	{value: 0x0000, lo: 0x03},
+	{value: 0x2621, lo: 0xb3, hi: 0xb3},
+	{value: 0x8122, lo: 0xb8, hi: 0xb9},
+	{value: 0x8104, lo: 0xba, hi: 0xba},
+	// Block 0x21, offset 0xe8
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8123, lo: 0x88, hi: 0x8b},
+	// Block 0x22, offset 0xea
+	{value: 0x0000, lo: 0x02},
+	{value: 0x2636, lo: 0xb3, hi: 0xb3},
+	{value: 0x8124, lo: 0xb8, hi: 0xb9},
+	// Block 0x23, offset 0xed
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8125, lo: 0x88, hi: 0x8b},
+	{value: 0x2628, lo: 0x9c, hi: 0x9c},
+	{value: 0x262f, lo: 0x9d, hi: 0x9d},
+	// Block 0x24, offset 0xf1
+	{value: 0x0000, lo: 0x05},
+	{value: 0x030b, lo: 0x8c, hi: 0x8c},
+	{value: 0x812d, lo: 0x98, hi: 0x99},
+	{value: 0x812d, lo: 0xb5, hi: 0xb5},
+	{value: 0x812d, lo: 0xb7, hi: 0xb7},
+	{value: 0x812b, lo: 0xb9, hi: 0xb9},
+	// Block 0x25, offset 0xf7
+	{value: 0x0000, lo: 0x10},
+	{value: 0x2644, lo: 0x83, hi: 0x83},
+	{value: 0x264b, lo: 0x8d, hi: 0x8d},
+	{value: 0x2652, lo: 0x92, hi: 0x92},
+	{value: 0x2659, lo: 0x97, hi: 0x97},
+	{value: 0x2660, lo: 0x9c, hi: 0x9c},
+	{value: 0x263d, lo: 0xa9, hi: 0xa9},
+	{value: 0x8126, lo: 0xb1, hi: 0xb1},
+	{value: 0x8127, lo: 0xb2, hi: 0xb2},
+	{value: 0x4a84, lo: 0xb3, hi: 0xb3},
+	{value: 0x8128, lo: 0xb4, hi: 0xb4},
+	{value: 0x4a8d, lo: 0xb5, hi: 0xb5},
+	{value: 0x45b4, lo: 0xb6, hi: 0xb6},
+	{value: 0x45f4, lo: 0xb7, hi: 0xb7},
+	{value: 0x45bc, lo: 0xb8, hi: 0xb8},
+	{value: 0x45ff, lo: 0xb9, hi: 0xb9},
+	{value: 0x8127, lo: 0xba, hi: 0xbd},
+	// Block 0x26, offset 0x108
+	{value: 0x0000, lo: 0x0b},
+	{value: 0x8127, lo: 0x80, hi: 0x80},
+	{value: 0x4a96, lo: 0x81, hi: 0x81},
+	{value: 0x8132, lo: 0x82, hi: 0x83},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0x86, hi: 0x87},
+	{value: 0x266e, lo: 0x93, hi: 0x93},
+	{value: 0x2675, lo: 0x9d, hi: 0x9d},
+	{value: 0x267c, lo: 0xa2, hi: 0xa2},
+	{value: 0x2683, lo: 0xa7, hi: 0xa7},
+	{value: 0x268a, lo: 0xac, hi: 0xac},
+	{value: 0x2667, lo: 0xb9, hi: 0xb9},
+	// Block 0x27, offset 0x114
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x86, hi: 0x86},
+	// Block 0x28, offset 0x116
+	{value: 0x0000, lo: 0x05},
+	{value: 0xa000, lo: 0xa5, hi: 0xa5},
+	{value: 0x2d1e, lo: 0xa6, hi: 0xa6},
+	{value: 0x9900, lo: 0xae, hi: 0xae},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	{value: 0x8104, lo: 0xb9, hi: 0xba},
+	// Block 0x29, offset 0x11c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x8d, hi: 0x8d},
+	// Block 0x2a, offset 0x11e
+	{value: 0x0000, lo: 0x01},
+	{value: 0x030f, lo: 0xbc, hi: 0xbc},
+	// Block 0x2b, offset 0x120
+	{value: 0x0000, lo: 0x01},
+	{value: 0xa000, lo: 0x80, hi: 0x92},
+	// Block 0x2c, offset 0x122
+	{value: 0x0000, lo: 0x01},
+	{value: 0xb900, lo: 0xa1, hi: 0xb5},
+	// Block 0x2d, offset 0x124
+	{value: 0x0000, lo: 0x01},
+	{value: 0x9900, lo: 0xa8, hi: 0xbf},
+	// Block 0x2e, offset 0x126
+	{value: 0x0000, lo: 0x01},
+	{value: 0x9900, lo: 0x80, hi: 0x82},
+	// Block 0x2f, offset 0x128
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x9d, hi: 0x9f},
+	// Block 0x30, offset 0x12a
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x94, hi: 0x94},
+	{value: 0x8104, lo: 0xb4, hi: 0xb4},
+	// Block 0x31, offset 0x12d
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x92, hi: 0x92},
+	{value: 0x8132, lo: 0x9d, hi: 0x9d},
+	// Block 0x32, offset 0x130
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8131, lo: 0xa9, hi: 0xa9},
+	// Block 0x33, offset 0x132
+	{value: 0x0004, lo: 0x02},
+	{value: 0x812e, lo: 0xb9, hi: 0xba},
+	{value: 0x812d, lo: 0xbb, hi: 0xbb},
+	// Block 0x34, offset 0x135
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x97, hi: 0x97},
+	{value: 0x812d, lo: 0x98, hi: 0x98},
+	// Block 0x35, offset 0x138
+	{value: 0x0000, lo: 0x03},
+	{value: 0x8104, lo: 0xa0, hi: 0xa0},
+	{value: 0x8132, lo: 0xb5, hi: 0xbc},
+	{value: 0x812d, lo: 0xbf, hi: 0xbf},
+	// Block 0x36, offset 0x13c
+	{value: 0x0000, lo: 0x04},
+	{value: 0x8132, lo: 0xb0, hi: 0xb4},
+	{value: 0x812d, lo: 0xb5, hi: 0xba},
+	{value: 0x8132, lo: 0xbb, hi: 0xbc},
+	{value: 0x812d, lo: 0xbd, hi: 0xbd},
+	// Block 0x37, offset 0x141
+	{value: 0x0000, lo: 0x08},
+	{value: 0x2d66, lo: 0x80, hi: 0x80},
+	{value: 0x2d6e, lo: 0x81, hi: 0x81},
+	{value: 0xa000, lo: 0x82, hi: 0x82},
+	{value: 0x2d76, lo: 0x83, hi: 0x83},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0xab, hi: 0xab},
+	{value: 0x812d, lo: 0xac, hi: 0xac},
+	{value: 0x8132, lo: 0xad, hi: 0xb3},
+	// Block 0x38, offset 0x14a
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xaa, hi: 0xab},
+	// Block 0x39, offset 0x14c
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0xa6, hi: 0xa6},
+	{value: 0x8104, lo: 0xb2, hi: 0xb3},
+	// Block 0x3a, offset 0x14f
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	// Block 0x3b, offset 0x151
+	{value: 0x0000, lo: 0x0a},
+	{value: 0x8132, lo: 0x90, hi: 0x92},
+	{value: 0x8101, lo: 0x94, hi: 0x94},
+	{value: 0x812d, lo: 0x95, hi: 0x99},
+	{value: 0x8132, lo: 0x9a, hi: 0x9b},
+	{value: 0x812d, lo: 0x9c, hi: 0x9f},
+	{value: 0x8132, lo: 0xa0, hi: 0xa0},
+	{value: 0x8101, lo: 0xa2, hi: 0xa8},
+	{value: 0x812d, lo: 0xad, hi: 0xad},
+	{value: 0x8132, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb8, hi: 0xb9},
+	// Block 0x3c, offset 0x15c
+	{value: 0x0002, lo: 0x0a},
+	{value: 0x0043, lo: 0xac, hi: 0xac},
+	{value: 0x00d1, lo: 0xad, hi: 0xad},
+	{value: 0x0045, lo: 0xae, hi: 0xae},
+	{value: 0x0049, lo: 0xb0, hi: 0xb1},
+	{value: 0x00e6, lo: 0xb2, hi: 0xb2},
+	{value: 0x004f, lo: 0xb3, hi: 0xba},
+	{value: 0x005f, lo: 0xbc, hi: 0xbc},
+	{value: 0x00ef, lo: 0xbd, hi: 0xbd},
+	{value: 0x0061, lo: 0xbe, hi: 0xbe},
+	{value: 0x0065, lo: 0xbf, hi: 0xbf},
+	// Block 0x3d, offset 0x167
+	{value: 0x0000, lo: 0x0d},
+	{value: 0x0001, lo: 0x80, hi: 0x8a},
+	{value: 0x043b, lo: 0x91, hi: 0x91},
+	{value: 0x429b, lo: 0x97, hi: 0x97},
+	{value: 0x001d, lo: 0xa4, hi: 0xa4},
+	{value: 0x1873, lo: 0xa5, hi: 0xa5},
+	{value: 0x1b5c, lo: 0xa6, hi: 0xa6},
+	{value: 0x0001, lo: 0xaf, hi: 0xaf},
+	{value: 0x2691, lo: 0xb3, hi: 0xb3},
+	{value: 0x27fe, lo: 0xb4, hi: 0xb4},
+	{value: 0x2698, lo: 0xb6, hi: 0xb6},
+	{value: 0x2808, lo: 0xb7, hi: 0xb7},
+	{value: 0x186d, lo: 0xbc, hi: 0xbc},
+	{value: 0x4269, lo: 0xbe, hi: 0xbe},
+	// Block 0x3e, offset 0x175
+	{value: 0x0002, lo: 0x0d},
+	{value: 0x1933, lo: 0x87, hi: 0x87},
+	{value: 0x1930, lo: 0x88, hi: 0x88},
+	{value: 0x1870, lo: 0x89, hi: 0x89},
+	{value: 0x298e, lo: 0x97, hi: 0x97},
+	{value: 0x0001, lo: 0x9f, hi: 0x9f},
+	{value: 0x0021, lo: 0xb0, hi: 0xb0},
+	{value: 0x0093, lo: 0xb1, hi: 0xb1},
+	{value: 0x0029, lo: 0xb4, hi: 0xb9},
+	{value: 0x0017, lo: 0xba, hi: 0xba},
+	{value: 0x0467, lo: 0xbb, hi: 0xbb},
+	{value: 0x003b, lo: 0xbc, hi: 0xbc},
+	{value: 0x0011, lo: 0xbd, hi: 0xbe},
+	{value: 0x009d, lo: 0xbf, hi: 0xbf},
+	// Block 0x3f, offset 0x183
+	{value: 0x0002, lo: 0x0f},
+	{value: 0x0021, lo: 0x80, hi: 0x89},
+	{value: 0x0017, lo: 0x8a, hi: 0x8a},
+	{value: 0x0467, lo: 0x8b, hi: 0x8b},
+	{value: 0x003b, lo: 0x8c, hi: 0x8c},
+	{value: 0x0011, lo: 0x8d, hi: 0x8e},
+	{value: 0x0083, lo: 0x90, hi: 0x90},
+	{value: 0x008b, lo: 0x91, hi: 0x91},
+	{value: 0x009f, lo: 0x92, hi: 0x92},
+	{value: 0x00b1, lo: 0x93, hi: 0x93},
+	{value: 0x0104, lo: 0x94, hi: 0x94},
+	{value: 0x0091, lo: 0x95, hi: 0x95},
+	{value: 0x0097, lo: 0x96, hi: 0x99},
+	{value: 0x00a1, lo: 0x9a, hi: 0x9a},
+	{value: 0x00a7, lo: 0x9b, hi: 0x9c},
+	{value: 0x1999, lo: 0xa8, hi: 0xa8},
+	// Block 0x40, offset 0x193
+	{value: 0x0000, lo: 0x0d},
+	{value: 0x8132, lo: 0x90, hi: 0x91},
+	{value: 0x8101, lo: 0x92, hi: 0x93},
+	{value: 0x8132, lo: 0x94, hi: 0x97},
+	{value: 0x8101, lo: 0x98, hi: 0x9a},
+	{value: 0x8132, lo: 0x9b, hi: 0x9c},
+	{value: 0x8132, lo: 0xa1, hi: 0xa1},
+	{value: 0x8101, lo: 0xa5, hi: 0xa6},
+	{value: 0x8132, lo: 0xa7, hi: 0xa7},
+	{value: 0x812d, lo: 0xa8, hi: 0xa8},
+	{value: 0x8132, lo: 0xa9, hi: 0xa9},
+	{value: 0x8101, lo: 0xaa, hi: 0xab},
+	{value: 0x812d, lo: 0xac, hi: 0xaf},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	// Block 0x41, offset 0x1a1
+	{value: 0x0007, lo: 0x06},
+	{value: 0x2180, lo: 0x89, hi: 0x89},
+	{value: 0xa000, lo: 0x90, hi: 0x90},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0xa000, lo: 0x94, hi: 0x94},
+	{value: 0x3bb9, lo: 0x9a, hi: 0x9b},
+	{value: 0x3bc7, lo: 0xae, hi: 0xae},
+	// Block 0x42, offset 0x1a8
+	{value: 0x000e, lo: 0x05},
+	{value: 0x3bce, lo: 0x8d, hi: 0x8e},
+	{value: 0x3bd5, lo: 0x8f, hi: 0x8f},
+	{value: 0xa000, lo: 0x90, hi: 0x90},
+	{value: 0xa000, lo: 0x92, hi: 0x92},
+	{value: 0xa000, lo: 0x94, hi: 0x94},
+	// Block 0x43, offset 0x1ae
+	{value: 0x0173, lo: 0x0e},
+	{value: 0xa000, lo: 0x83, hi: 0x83},
+	{value: 0x3be3, lo: 0x84, hi: 0x84},
+	{value: 0xa000, lo: 0x88, hi: 0x88},
+	{value: 0x3bea, lo: 0x89, hi: 0x89},
+	{value: 0xa000, lo: 0x8b, hi: 0x8b},
+	{value: 0x3bf1, lo: 0x8c, hi: 0x8c},
+	{value: 0xa000, lo: 0xa3, hi: 0xa3},
+	{value: 0x3bf8, lo: 0xa4, hi: 0xa4},
+	{value: 0xa000, lo: 0xa5, hi: 0xa5},
+	{value: 0x3bff, lo: 0xa6, hi: 0xa6},
+	{value: 0x269f, lo: 0xac, hi: 0xad},
+	{value: 0x26a6, lo: 0xaf, hi: 0xaf},
+	{value: 0x281c, lo: 0xb0, hi: 0xb0},
+	{value: 0xa000, lo: 0xbc, hi: 0xbc},
+	// Block 0x44, offset 0x1bd
+	{value: 0x0007, lo: 0x03},
+	{value: 0x3c68, lo: 0xa0, hi: 0xa1},
+	{value: 0x3c92, lo: 0xa2, hi: 0xa3},
+	{value: 0x3cbc, lo: 0xaa, hi: 0xad},
+	// Block 0x45, offset 0x1c1
+	{value: 0x0004, lo: 0x01},
+	{value: 0x048b, lo: 0xa9, hi: 0xaa},
+	// Block 0x46, offset 0x1c3
+	{value: 0x0002, lo: 0x03},
+	{value: 0x0057, lo: 0x80, hi: 0x8f},
+	{value: 0x0083, lo: 0x90, hi: 0xa9},
+	{value: 0x0021, lo: 0xaa, hi: 0xaa},
+	// Block 0x47, offset 0x1c7
+	{value: 0x0000, lo: 0x01},
+	{value: 0x299b, lo: 0x8c, hi: 0x8c},
+	// Block 0x48, offset 0x1c9
+	{value: 0x0263, lo: 0x02},
+	{value: 0x1b8c, lo: 0xb4, hi: 0xb4},
+	{value: 0x192d, lo: 0xb5, hi: 0xb6},
+	// Block 0x49, offset 0x1cc
+	{value: 0x0000, lo: 0x01},
+	{value: 0x44dd, lo: 0x9c, hi: 0x9c},
+	// Block 0x4a, offset 0x1ce
+	{value: 0x0000, lo: 0x02},
+	{value: 0x0095, lo: 0xbc, hi: 0xbc},
+	{value: 0x006d, lo: 0xbd, hi: 0xbd},
+	// Block 0x4b, offset 0x1d1
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xaf, hi: 0xb1},
+	// Block 0x4c, offset 0x1d3
+	{value: 0x0000, lo: 0x02},
+	{value: 0x047f, lo: 0xaf, hi: 0xaf},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x4d, offset 0x1d6
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xa0, hi: 0xbf},
+	// Block 0x4e, offset 0x1d8
+	{value: 0x0000, lo: 0x01},
+	{value: 0x0dc3, lo: 0x9f, hi: 0x9f},
+	// Block 0x4f, offset 0x1da
+	{value: 0x0000, lo: 0x01},
+	{value: 0x162f, lo: 0xb3, hi: 0xb3},
+	// Block 0x50, offset 0x1dc
+	{value: 0x0004, lo: 0x0b},
+	{value: 0x1597, lo: 0x80, hi: 0x82},
+	{value: 0x15af, lo: 0x83, hi: 0x83},
+	{value: 0x15c7, lo: 0x84, hi: 0x85},
+	{value: 0x15d7, lo: 0x86, hi: 0x89},
+	{value: 0x15eb, lo: 0x8a, hi: 0x8c},
+	{value: 0x15ff, lo: 0x8d, hi: 0x8d},
+	{value: 0x1607, lo: 0x8e, hi: 0x8e},
+	{value: 0x160f, lo: 0x8f, hi: 0x90},
+	{value: 0x161b, lo: 0x91, hi: 0x93},
+	{value: 0x162b, lo: 0x94, hi: 0x94},
+	{value: 0x1633, lo: 0x95, hi: 0x95},
+	// Block 0x51, offset 0x1e8
+	{value: 0x0004, lo: 0x09},
+	{value: 0x0001, lo: 0x80, hi: 0x80},
+	{value: 0x812c, lo: 0xaa, hi: 0xaa},
+	{value: 0x8131, lo: 0xab, hi: 0xab},
+	{value: 0x8133, lo: 0xac, hi: 0xac},
+	{value: 0x812e, lo: 0xad, hi: 0xad},
+	{value: 0x812f, lo: 0xae, hi: 0xae},
+	{value: 0x812f, lo: 0xaf, hi: 0xaf},
+	{value: 0x04b3, lo: 0xb6, hi: 0xb6},
+	{value: 0x0887, lo: 0xb8, hi: 0xba},
+	// Block 0x52, offset 0x1f2
+	{value: 0x0006, lo: 0x09},
+	{value: 0x0313, lo: 0xb1, hi: 0xb1},
+	{value: 0x0317, lo: 0xb2, hi: 0xb2},
+	{value: 0x4a3b, lo: 0xb3, hi: 0xb3},
+	{value: 0x031b, lo: 0xb4, hi: 0xb4},
+	{value: 0x4a41, lo: 0xb5, hi: 0xb6},
+	{value: 0x031f, lo: 0xb7, hi: 0xb7},
+	{value: 0x0323, lo: 0xb8, hi: 0xb8},
+	{value: 0x0327, lo: 0xb9, hi: 0xb9},
+	{value: 0x4a4d, lo: 0xba, hi: 0xbf},
+	// Block 0x53, offset 0x1fc
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0xaf, hi: 0xaf},
+	{value: 0x8132, lo: 0xb4, hi: 0xbd},
+	// Block 0x54, offset 0x1ff
+	{value: 0x0000, lo: 0x03},
+	{value: 0x020f, lo: 0x9c, hi: 0x9c},
+	{value: 0x0212, lo: 0x9d, hi: 0x9d},
+	{value: 0x8132, lo: 0x9e, hi: 0x9f},
+	// Block 0x55, offset 0x203
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb0, hi: 0xb1},
+	// Block 0x56, offset 0x205
+	{value: 0x0000, lo: 0x01},
+	{value: 0x163b, lo: 0xb0, hi: 0xb0},
+	// Block 0x57, offset 0x207
+	{value: 0x000c, lo: 0x01},
+	{value: 0x00d7, lo: 0xb8, hi: 0xb9},
+	// Block 0x58, offset 0x209
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x86, hi: 0x86},
+	// Block 0x59, offset 0x20b
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x84, hi: 0x84},
+	{value: 0x8132, lo: 0xa0, hi: 0xb1},
+	// Block 0x5a, offset 0x20e
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xab, hi: 0xad},
+	// Block 0x5b, offset 0x210
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x93, hi: 0x93},
+	// Block 0x5c, offset 0x212
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0xb3, hi: 0xb3},
+	// Block 0x5d, offset 0x214
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x80, hi: 0x80},
+	// Block 0x5e, offset 0x216
+	{value: 0x0000, lo: 0x05},
+	{value: 0x8132, lo: 0xb0, hi: 0xb0},
+	{value: 0x8132, lo: 0xb2, hi: 0xb3},
+	{value: 0x812d, lo: 0xb4, hi: 0xb4},
+	{value: 0x8132, lo: 0xb7, hi: 0xb8},
+	{value: 0x8132, lo: 0xbe, hi: 0xbf},
+	// Block 0x5f, offset 0x21c
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x81, hi: 0x81},
+	{value: 0x8104, lo: 0xb6, hi: 0xb6},
+	// Block 0x60, offset 0x21f
+	{value: 0x0008, lo: 0x03},
+	{value: 0x1637, lo: 0x9c, hi: 0x9d},
+	{value: 0x0125, lo: 0x9e, hi: 0x9e},
+	{value: 0x1643, lo: 0x9f, hi: 0x9f},
+	// Block 0x61, offset 0x223
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xad, hi: 0xad},
+	// Block 0x62, offset 0x225
+	{value: 0x0000, lo: 0x06},
+	{value: 0xe500, lo: 0x80, hi: 0x80},
+	{value: 0xc600, lo: 0x81, hi: 0x9b},
+	{value: 0xe500, lo: 0x9c, hi: 0x9c},
+	{value: 0xc600, lo: 0x9d, hi: 0xb7},
+	{value: 0xe500, lo: 0xb8, hi: 0xb8},
+	{value: 0xc600, lo: 0xb9, hi: 0xbf},
+	// Block 0x63, offset 0x22c
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x93},
+	{value: 0xe500, lo: 0x94, hi: 0x94},
+	{value: 0xc600, lo: 0x95, hi: 0xaf},
+	{value: 0xe500, lo: 0xb0, hi: 0xb0},
+	{value: 0xc600, lo: 0xb1, hi: 0xbf},
+	// Block 0x64, offset 0x232
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x8b},
+	{value: 0xe500, lo: 0x8c, hi: 0x8c},
+	{value: 0xc600, lo: 0x8d, hi: 0xa7},
+	{value: 0xe500, lo: 0xa8, hi: 0xa8},
+	{value: 0xc600, lo: 0xa9, hi: 0xbf},
+	// Block 0x65, offset 0x238
+	{value: 0x0000, lo: 0x07},
+	{value: 0xc600, lo: 0x80, hi: 0x83},
+	{value: 0xe500, lo: 0x84, hi: 0x84},
+	{value: 0xc600, lo: 0x85, hi: 0x9f},
+	{value: 0xe500, lo: 0xa0, hi: 0xa0},
+	{value: 0xc600, lo: 0xa1, hi: 0xbb},
+	{value: 0xe500, lo: 0xbc, hi: 0xbc},
+	{value: 0xc600, lo: 0xbd, hi: 0xbf},
+	// Block 0x66, offset 0x240
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x97},
+	{value: 0xe500, lo: 0x98, hi: 0x98},
+	{value: 0xc600, lo: 0x99, hi: 0xb3},
+	{value: 0xe500, lo: 0xb4, hi: 0xb4},
+	{value: 0xc600, lo: 0xb5, hi: 0xbf},
+	// Block 0x67, offset 0x246
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x8f},
+	{value: 0xe500, lo: 0x90, hi: 0x90},
+	{value: 0xc600, lo: 0x91, hi: 0xab},
+	{value: 0xe500, lo: 0xac, hi: 0xac},
+	{value: 0xc600, lo: 0xad, hi: 0xbf},
+	// Block 0x68, offset 0x24c
+	{value: 0x0000, lo: 0x05},
+	{value: 0xc600, lo: 0x80, hi: 0x87},
+	{value: 0xe500, lo: 0x88, hi: 0x88},
+	{value: 0xc600, lo: 0x89, hi: 0xa3},
+	{value: 0xe500, lo: 0xa4, hi: 0xa4},
+	{value: 0xc600, lo: 0xa5, hi: 0xbf},
+	// Block 0x69, offset 0x252
+	{value: 0x0000, lo: 0x03},
+	{value: 0xc600, lo: 0x80, hi: 0x87},
+	{value: 0xe500, lo: 0x88, hi: 0x88},
+	{value: 0xc600, lo: 0x89, hi: 0xa3},
+	// Block 0x6a, offset 0x256
+	{value: 0x0002, lo: 0x01},
+	{value: 0x0003, lo: 0x81, hi: 0xbf},
+	// Block 0x6b, offset 0x258
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xbd, hi: 0xbd},
+	// Block 0x6c, offset 0x25a
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0xa0, hi: 0xa0},
+	// Block 0x6d, offset 0x25c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb6, hi: 0xba},
+	// Block 0x6e, offset 0x25e
+	{value: 0x002c, lo: 0x05},
+	{value: 0x812d, lo: 0x8d, hi: 0x8d},
+	{value: 0x8132, lo: 0x8f, hi: 0x8f},
+	{value: 0x8132, lo: 0xb8, hi: 0xb8},
+	{value: 0x8101, lo: 0xb9, hi: 0xba},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x6f, offset 0x264
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0xa5, hi: 0xa5},
+	{value: 0x812d, lo: 0xa6, hi: 0xa6},
+	// Block 0x70, offset 0x267
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x86, hi: 0x86},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x71, offset 0x26a
+	{value: 0x17fe, lo: 0x07},
+	{value: 0xa000, lo: 0x99, hi: 0x99},
+	{value: 0x4238, lo: 0x9a, hi: 0x9a},
+	{value: 0xa000, lo: 0x9b, hi: 0x9b},
+	{value: 0x4242, lo: 0x9c, hi: 0x9c},
+	{value: 0xa000, lo: 0xa5, hi: 0xa5},
+	{value: 0x424c, lo: 0xab, hi: 0xab},
+	{value: 0x8104, lo: 0xb9, hi: 0xba},
+	// Block 0x72, offset 0x272
+	{value: 0x0000, lo: 0x06},
+	{value: 0x8132, lo: 0x80, hi: 0x82},
+	{value: 0x9900, lo: 0xa7, hi: 0xa7},
+	{value: 0x2d7e, lo: 0xae, hi: 0xae},
+	{value: 0x2d88, lo: 0xaf, hi: 0xaf},
+	{value: 0xa000, lo: 0xb1, hi: 0xb2},
+	{value: 0x8104, lo: 0xb3, hi: 0xb4},
+	// Block 0x73, offset 0x279
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x80, hi: 0x80},
+	{value: 0x8102, lo: 0x8a, hi: 0x8a},
+	// Block 0x74, offset 0x27c
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xb5, hi: 0xb5},
+	{value: 0x8102, lo: 0xb6, hi: 0xb6},
+	// Block 0x75, offset 0x27f
+	{value: 0x0002, lo: 0x01},
+	{value: 0x8102, lo: 0xa9, hi: 0xaa},
+	// Block 0x76, offset 0x281
+	{value: 0x0000, lo: 0x07},
+	{value: 0xa000, lo: 0x87, hi: 0x87},
+	{value: 0x2d92, lo: 0x8b, hi: 0x8b},
+	{value: 0x2d9c, lo: 0x8c, hi: 0x8c},
+	{value: 0x8104, lo: 0x8d, hi: 0x8d},
+	{value: 0x9900, lo: 0x97, hi: 0x97},
+	{value: 0x8132, lo: 0xa6, hi: 0xac},
+	{value: 0x8132, lo: 0xb0, hi: 0xb4},
+	// Block 0x77, offset 0x289
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x82, hi: 0x82},
+	{value: 0x8102, lo: 0x86, hi: 0x86},
+	// Block 0x78, offset 0x28c
+	{value: 0x6b5a, lo: 0x06},
+	{value: 0x9900, lo: 0xb0, hi: 0xb0},
+	{value: 0xa000, lo: 0xb9, hi: 0xb9},
+	{value: 0x9900, lo: 0xba, hi: 0xba},
+	{value: 0x2db0, lo: 0xbb, hi: 0xbb},
+	{value: 0x2da6, lo: 0xbc, hi: 0xbd},
+	{value: 0x2dba, lo: 0xbe, hi: 0xbe},
+	// Block 0x79, offset 0x293
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0x82, hi: 0x82},
+	{value: 0x8102, lo: 0x83, hi: 0x83},
+	// Block 0x7a, offset 0x296
+	{value: 0x0000, lo: 0x05},
+	{value: 0x9900, lo: 0xaf, hi: 0xaf},
+	{value: 0xa000, lo: 0xb8, hi: 0xb9},
+	{value: 0x2dc4, lo: 0xba, hi: 0xba},
+	{value: 0x2dce, lo: 0xbb, hi: 0xbb},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x7b, offset 0x29c
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8102, lo: 0x80, hi: 0x80},
+	// Block 0x7c, offset 0x29e
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xbf, hi: 0xbf},
+	// Block 0x7d, offset 0x2a0
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8104, lo: 0xb6, hi: 0xb6},
+	{value: 0x8102, lo: 0xb7, hi: 0xb7},
+	// Block 0x7e, offset 0x2a3
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xab, hi: 0xab},
+	// Block 0x7f, offset 0x2a5
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0xb4, hi: 0xb4},
+	// Block 0x80, offset 0x2a7
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x87, hi: 0x87},
+	// Block 0x81, offset 0x2a9
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8104, lo: 0x99, hi: 0x99},
+	// Block 0x82, offset 0x2ab
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8102, lo: 0x82, hi: 0x82},
+	{value: 0x8104, lo: 0x84, hi: 0x85},
+	// Block 0x83, offset 0x2ae
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8101, lo: 0xb0, hi: 0xb4},
+	// Block 0x84, offset 0x2b0
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0xb0, hi: 0xb6},
+	// Block 0x85, offset 0x2b2
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8101, lo: 0x9e, hi: 0x9e},
+	// Block 0x86, offset 0x2b4
+	{value: 0x0000, lo: 0x0c},
+	{value: 0x45cc, lo: 0x9e, hi: 0x9e},
+	{value: 0x45d6, lo: 0x9f, hi: 0x9f},
+	{value: 0x460a, lo: 0xa0, hi: 0xa0},
+	{value: 0x4618, lo: 0xa1, hi: 0xa1},
+	{value: 0x4626, lo: 0xa2, hi: 0xa2},
+	{value: 0x4634, lo: 0xa3, hi: 0xa3},
+	{value: 0x4642, lo: 0xa4, hi: 0xa4},
+	{value: 0x812b, lo: 0xa5, hi: 0xa6},
+	{value: 0x8101, lo: 0xa7, hi: 0xa9},
+	{value: 0x8130, lo: 0xad, hi: 0xad},
+	{value: 0x812b, lo: 0xae, hi: 0xb2},
+	{value: 0x812d, lo: 0xbb, hi: 0xbf},
+	// Block 0x87, offset 0x2c1
+	{value: 0x0000, lo: 0x09},
+	{value: 0x812d, lo: 0x80, hi: 0x82},
+	{value: 0x8132, lo: 0x85, hi: 0x89},
+	{value: 0x812d, lo: 0x8a, hi: 0x8b},
+	{value: 0x8132, lo: 0xaa, hi: 0xad},
+	{value: 0x45e0, lo: 0xbb, hi: 0xbb},
+	{value: 0x45ea, lo: 0xbc, hi: 0xbc},
+	{value: 0x4650, lo: 0xbd, hi: 0xbd},
+	{value: 0x466c, lo: 0xbe, hi: 0xbe},
+	{value: 0x465e, lo: 0xbf, hi: 0xbf},
+	// Block 0x88, offset 0x2cb
+	{value: 0x0000, lo: 0x01},
+	{value: 0x467a, lo: 0x80, hi: 0x80},
+	// Block 0x89, offset 0x2cd
+	{value: 0x0000, lo: 0x01},
+	{value: 0x8132, lo: 0x82, hi: 0x84},
+	// Block 0x8a, offset 0x2cf
+	{value: 0x0002, lo: 0x03},
+	{value: 0x0043, lo: 0x80, hi: 0x99},
+	{value: 0x0083, lo: 0x9a, hi: 0xb3},
+	{value: 0x0043, lo: 0xb4, hi: 0xbf},
+	// Block 0x8b, offset 0x2d3
+	{value: 0x0002, lo: 0x04},
+	{value: 0x005b, lo: 0x80, hi: 0x8d},
+	{value: 0x0083, lo: 0x8e, hi: 0x94},
+	{value: 0x0093, lo: 0x96, hi: 0xa7},
+	{value: 0x0043, lo: 0xa8, hi: 0xbf},
+	// Block 0x8c, offset 0x2d8
+	{value: 0x0002, lo: 0x0b},
+	{value: 0x0073, lo: 0x80, hi: 0x81},
+	{value: 0x0083, lo: 0x82, hi: 0x9b},
+	{value: 0x0043, lo: 0x9c, hi: 0x9c},
+	{value: 0x0047, lo: 0x9e, hi: 0x9f},
+	{value: 0x004f, lo: 0xa2, hi: 0xa2},
+	{value: 0x0055, lo: 0xa5, hi: 0xa6},
+	{value: 0x005d, lo: 0xa9, hi: 0xac},
+	{value: 0x0067, lo: 0xae, hi: 0xb5},
+	{value: 0x0083, lo: 0xb6, hi: 0xb9},
+	{value: 0x008d, lo: 0xbb, hi: 0xbb},
+	{value: 0x0091, lo: 0xbd, hi: 0xbf},
+	// Block 0x8d, offset 0x2e4
+	{value: 0x0002, lo: 0x04},
+	{value: 0x0097, lo: 0x80, hi: 0x83},
+	{value: 0x00a1, lo: 0x85, hi: 0x8f},
+	{value: 0x0043, lo: 0x90, hi: 0xa9},
+	{value: 0x0083, lo: 0xaa, hi: 0xbf},
+	// Block 0x8e, offset 0x2e9
+	{value: 0x0002, lo: 0x08},
+	{value: 0x00af, lo: 0x80, hi: 0x83},
+	{value: 0x0043, lo: 0x84, hi: 0x85},
+	{value: 0x0049, lo: 0x87, hi: 0x8a},
+	{value: 0x0055, lo: 0x8d, hi: 0x94},
+	{value: 0x0067, lo: 0x96, hi: 0x9c},
+	{value: 0x0083, lo: 0x9e, hi: 0xb7},
+	{value: 0x0043, lo: 0xb8, hi: 0xb9},
+	{value: 0x0049, lo: 0xbb, hi: 0xbe},
+	// Block 0x8f, offset 0x2f2
+	{value: 0x0002, lo: 0x05},
+	{value: 0x0053, lo: 0x80, hi: 0x84},
+	{value: 0x005f, lo: 0x86, hi: 0x86},
+	{value: 0x0067, lo: 0x8a, hi: 0x90},
+	{value: 0x0083, lo: 0x92, hi: 0xab},
+	{value: 0x0043, lo: 0xac, hi: 0xbf},
+	// Block 0x90, offset 0x2f8
+	{value: 0x0002, lo: 0x04},
+	{value: 0x006b, lo: 0x80, hi: 0x85},
+	{value: 0x0083, lo: 0x86, hi: 0x9f},
+	{value: 0x0043, lo: 0xa0, hi: 0xb9},
+	{value: 0x0083, lo: 0xba, hi: 0xbf},
+	// Block 0x91, offset 0x2fd
+	{value: 0x0002, lo: 0x03},
+	{value: 0x008f, lo: 0x80, hi: 0x93},
+	{value: 0x0043, lo: 0x94, hi: 0xad},
+	{value: 0x0083, lo: 0xae, hi: 0xbf},
+	// Block 0x92, offset 0x301
+	{value: 0x0002, lo: 0x04},
+	{value: 0x00a7, lo: 0x80, hi: 0x87},
+	{value: 0x0043, lo: 0x88, hi: 0xa1},
+	{value: 0x0083, lo: 0xa2, hi: 0xbb},
+	{value: 0x0043, lo: 0xbc, hi: 0xbf},
+	// Block 0x93, offset 0x306
+	{value: 0x0002, lo: 0x03},
+	{value: 0x004b, lo: 0x80, hi: 0x95},
+	{value: 0x0083, lo: 0x96, hi: 0xaf},
+	{value: 0x0043, lo: 0xb0, hi: 0xbf},
+	// Block 0x94, offset 0x30a
+	{value: 0x0003, lo: 0x0f},
+	{value: 0x01b8, lo: 0x80, hi: 0x80},
+	{value: 0x045f, lo: 0x81, hi: 0x81},
+	{value: 0x01bb, lo: 0x82, hi: 0x9a},
+	{value: 0x045b, lo: 0x9b, hi: 0x9b},
+	{value: 0x01c7, lo: 0x9c, hi: 0x9c},
+	{value: 0x01d0, lo: 0x9d, hi: 0x9d},
+	{value: 0x01d6, lo: 0x9e, hi: 0x9e},
+	{value: 0x01fa, lo: 0x9f, hi: 0x9f},
+	{value: 0x01eb, lo: 0xa0, hi: 0xa0},
+	{value: 0x01e8, lo: 0xa1, hi: 0xa1},
+	{value: 0x0173, lo: 0xa2, hi: 0xb2},
+	{value: 0x0188, lo: 0xb3, hi: 0xb3},
+	{value: 0x01a6, lo: 0xb4, hi: 0xba},
+	{value: 0x045f, lo: 0xbb, hi: 0xbb},
+	{value: 0x01bb, lo: 0xbc, hi: 0xbf},
+	// Block 0x95, offset 0x31a
+	{value: 0x0003, lo: 0x0d},
+	{value: 0x01c7, lo: 0x80, hi: 0x94},
+	{value: 0x045b, lo: 0x95, hi: 0x95},
+	{value: 0x01c7, lo: 0x96, hi: 0x96},
+	{value: 0x01d0, lo: 0x97, hi: 0x97},
+	{value: 0x01d6, lo: 0x98, hi: 0x98},
+	{value: 0x01fa, lo: 0x99, hi: 0x99},
+	{value: 0x01eb, lo: 0x9a, hi: 0x9a},
+	{value: 0x01e8, lo: 0x9b, hi: 0x9b},
+	{value: 0x0173, lo: 0x9c, hi: 0xac},
+	{value: 0x0188, lo: 0xad, hi: 0xad},
+	{value: 0x01a6, lo: 0xae, hi: 0xb4},
+	{value: 0x045f, lo: 0xb5, hi: 0xb5},
+	{value: 0x01bb, lo: 0xb6, hi: 0xbf},
+	// Block 0x96, offset 0x328
+	{value: 0x0003, lo: 0x0d},
+	{value: 0x01d9, lo: 0x80, hi: 0x8e},
+	{value: 0x045b, lo: 0x8f, hi: 0x8f},
+	{value: 0x01c7, lo: 0x90, hi: 0x90},
+	{value: 0x01d0, lo: 0x91, hi: 0x91},
+	{value: 0x01d6, lo: 0x92, hi: 0x92},
+	{value: 0x01fa, lo: 0x93, hi: 0x93},
+	{value: 0x01eb, lo: 0x94, hi: 0x94},
+	{value: 0x01e8, lo: 0x95, hi: 0x95},
+	{value: 0x0173, lo: 0x96, hi: 0xa6},
+	{value: 0x0188, lo: 0xa7, hi: 0xa7},
+	{value: 0x01a6, lo: 0xa8, hi: 0xae},
+	{value: 0x045f, lo: 0xaf, hi: 0xaf},
+	{value: 0x01bb, lo: 0xb0, hi: 0xbf},
+	// Block 0x97, offset 0x336
+	{value: 0x0003, lo: 0x0d},
+	{value: 0x01eb, lo: 0x80, hi: 0x88},
+	{value: 0x045b, lo: 0x89, hi: 0x89},
+	{value: 0x01c7, lo: 0x8a, hi: 0x8a},
+	{value: 0x01d0, lo: 0x8b, hi: 0x8b},
+	{value: 0x01d6, lo: 0x8c, hi: 0x8c},
+	{value: 0x01fa, lo: 0x8d, hi: 0x8d},
+	{value: 0x01eb, lo: 0x8e, hi: 0x8e},
+	{value: 0x01e8, lo: 0x8f, hi: 0x8f},
+	{value: 0x0173, lo: 0x90, hi: 0xa0},
+	{value: 0x0188, lo: 0xa1, hi: 0xa1},
+	{value: 0x01a6, lo: 0xa2, hi: 0xa8},
+	{value: 0x045f, lo: 0xa9, hi: 0xa9},
+	{value: 0x01bb, lo: 0xaa, hi: 0xbf},
+	// Block 0x98, offset 0x344
+	{value: 0x0000, lo: 0x05},
+	{value: 0x8132, lo: 0x80, hi: 0x86},
+	{value: 0x8132, lo: 0x88, hi: 0x98},
+	{value: 0x8132, lo: 0x9b, hi: 0xa1},
+	{value: 0x8132, lo: 0xa3, hi: 0xa4},
+	{value: 0x8132, lo: 0xa6, hi: 0xaa},
+	// Block 0x99, offset 0x34a
+	{value: 0x0000, lo: 0x01},
+	{value: 0x812d, lo: 0x90, hi: 0x96},
+	// Block 0x9a, offset 0x34c
+	{value: 0x0000, lo: 0x02},
+	{value: 0x8132, lo: 0x84, hi: 0x89},
+	{value: 0x8102, lo: 0x8a, hi: 0x8a},
+	// Block 0x9b, offset 0x34f
+	{value: 0x0002, lo: 0x09},
+	{value: 0x0063, lo: 0x80, hi: 0x89},
+	{value: 0x1951, lo: 0x8a, hi: 0x8a},
+	{value: 0x1981, lo: 0x8b, hi: 0x8b},
+	{value: 0x199c, lo: 0x8c, hi: 0x8c},
+	{value: 0x19a2, lo: 0x8d, hi: 0x8d},
+	{value: 0x1bc0, lo: 0x8e, hi: 0x8e},
+	{value: 0x19ae, lo: 0x8f, hi: 0x8f},
+	{value: 0x197b, lo: 0xaa, hi: 0xaa},
+	{value: 0x197e, lo: 0xab, hi: 0xab},
+	// Block 0x9c, offset 0x359
+	{value: 0x0000, lo: 0x01},
+	{value: 0x193f, lo: 0x90, hi: 0x90},
+	// Block 0x9d, offset 0x35b
+	{value: 0x0028, lo: 0x09},
+	{value: 0x2862, lo: 0x80, hi: 0x80},
+	{value: 0x2826, lo: 0x81, hi: 0x81},
+	{value: 0x2830, lo: 0x82, hi: 0x82},
+	{value: 0x2844, lo: 0x83, hi: 0x84},
+	{value: 0x284e, lo: 0x85, hi: 0x86},
+	{value: 0x283a, lo: 0x87, hi: 0x87},
+	{value: 0x2858, lo: 0x88, hi: 0x88},
+	{value: 0x0b6f, lo: 0x90, hi: 0x90},
+	{value: 0x08e7, lo: 0x91, hi: 0x91},
+}
+
+// recompMap: 7520 bytes (entries only)
+var recompMap = map[uint32]rune{
+	0x00410300: 0x00C0,
+	0x00410301: 0x00C1,
+	0x00410302: 0x00C2,
+	0x00410303: 0x00C3,
+	0x00410308: 0x00C4,
+	0x0041030A: 0x00C5,
+	0x00430327: 0x00C7,
+	0x00450300: 0x00C8,
+	0x00450301: 0x00C9,
+	0x00450302: 0x00CA,
+	0x00450308: 0x00CB,
+	0x00490300: 0x00CC,
+	0x00490301: 0x00CD,
+	0x00490302: 0x00CE,
+	0x00490308: 0x00CF,
+	0x004E0303: 0x00D1,
+	0x004F0300: 0x00D2,
+	0x004F0301: 0x00D3,
+	0x004F0302: 0x00D4,
+	0x004F0303: 0x00D5,
+	0x004F0308: 0x00D6,
+	0x00550300: 0x00D9,
+	0x00550301: 0x00DA,
+	0x00550302: 0x00DB,
+	0x00550308: 0x00DC,
+	0x00590301: 0x00DD,
+	0x00610300: 0x00E0,
+	0x00610301: 0x00E1,
+	0x00610302: 0x00E2,
+	0x00610303: 0x00E3,
+	0x00610308: 0x00E4,
+	0x0061030A: 0x00E5,
+	0x00630327: 0x00E7,
+	0x00650300: 0x00E8,
+	0x00650301: 0x00E9,
+	0x00650302: 0x00EA,
+	0x00650308: 0x00EB,
+	0x00690300: 0x00EC,
+	0x00690301: 0x00ED,
+	0x00690302: 0x00EE,
+	0x00690308: 0x00EF,
+	0x006E0303: 0x00F1,
+	0x006F0300: 0x00F2,
+	0x006F0301: 0x00F3,
+	0x006F0302: 0x00F4,
+	0x006F0303: 0x00F5,
+	0x006F0308: 0x00F6,
+	0x00750300: 0x00F9,
+	0x00750301: 0x00FA,
+	0x00750302: 0x00FB,
+	0x00750308: 0x00FC,
+	0x00790301: 0x00FD,
+	0x00790308: 0x00FF,
+	0x00410304: 0x0100,
+	0x00610304: 0x0101,
+	0x00410306: 0x0102,
+	0x00610306: 0x0103,
+	0x00410328: 0x0104,
+	0x00610328: 0x0105,
+	0x00430301: 0x0106,
+	0x00630301: 0x0107,
+	0x00430302: 0x0108,
+	0x00630302: 0x0109,
+	0x00430307: 0x010A,
+	0x00630307: 0x010B,
+	0x0043030C: 0x010C,
+	0x0063030C: 0x010D,
+	0x0044030C: 0x010E,
+	0x0064030C: 0x010F,
+	0x00450304: 0x0112,
+	0x00650304: 0x0113,
+	0x00450306: 0x0114,
+	0x00650306: 0x0115,
+	0x00450307: 0x0116,
+	0x00650307: 0x0117,
+	0x00450328: 0x0118,
+	0x00650328: 0x0119,
+	0x0045030C: 0x011A,
+	0x0065030C: 0x011B,
+	0x00470302: 0x011C,
+	0x00670302: 0x011D,
+	0x00470306: 0x011E,
+	0x00670306: 0x011F,
+	0x00470307: 0x0120,
+	0x00670307: 0x0121,
+	0x00470327: 0x0122,
+	0x00670327: 0x0123,
+	0x00480302: 0x0124,
+	0x00680302: 0x0125,
+	0x00490303: 0x0128,
+	0x00690303: 0x0129,
+	0x00490304: 0x012A,
+	0x00690304: 0x012B,
+	0x00490306: 0x012C,
+	0x00690306: 0x012D,
+	0x00490328: 0x012E,
+	0x00690328: 0x012F,
+	0x00490307: 0x0130,
+	0x004A0302: 0x0134,
+	0x006A0302: 0x0135,
+	0x004B0327: 0x0136,
+	0x006B0327: 0x0137,
+	0x004C0301: 0x0139,
+	0x006C0301: 0x013A,
+	0x004C0327: 0x013B,
+	0x006C0327: 0x013C,
+	0x004C030C: 0x013D,
+	0x006C030C: 0x013E,
+	0x004E0301: 0x0143,
+	0x006E0301: 0x0144,
+	0x004E0327: 0x0145,
+	0x006E0327: 0x0146,
+	0x004E030C: 0x0147,
+	0x006E030C: 0x0148,
+	0x004F0304: 0x014C,
+	0x006F0304: 0x014D,
+	0x004F0306: 0x014E,
+	0x006F0306: 0x014F,
+	0x004F030B: 0x0150,
+	0x006F030B: 0x0151,
+	0x00520301: 0x0154,
+	0x00720301: 0x0155,
+	0x00520327: 0x0156,
+	0x00720327: 0x0157,
+	0x0052030C: 0x0158,
+	0x0072030C: 0x0159,
+	0x00530301: 0x015A,
+	0x00730301: 0x015B,
+	0x00530302: 0x015C,
+	0x00730302: 0x015D,
+	0x00530327: 0x015E,
+	0x00730327: 0x015F,
+	0x0053030C: 0x0160,
+	0x0073030C: 0x0161,
+	0x00540327: 0x0162,
+	0x00740327: 0x0163,
+	0x0054030C: 0x0164,
+	0x0074030C: 0x0165,
+	0x00550303: 0x0168,
+	0x00750303: 0x0169,
+	0x00550304: 0x016A,
+	0x00750304: 0x016B,
+	0x00550306: 0x016C,
+	0x00750306: 0x016D,
+	0x0055030A: 0x016E,
+	0x0075030A: 0x016F,
+	0x0055030B: 0x0170,
+	0x0075030B: 0x0171,
+	0x00550328: 0x0172,
+	0x00750328: 0x0173,
+	0x00570302: 0x0174,
+	0x00770302: 0x0175,
+	0x00590302: 0x0176,
+	0x00790302: 0x0177,
+	0x00590308: 0x0178,
+	0x005A0301: 0x0179,
+	0x007A0301: 0x017A,
+	0x005A0307: 0x017B,
+	0x007A0307: 0x017C,
+	0x005A030C: 0x017D,
+	0x007A030C: 0x017E,
+	0x004F031B: 0x01A0,
+	0x006F031B: 0x01A1,
+	0x0055031B: 0x01AF,
+	0x0075031B: 0x01B0,
+	0x0041030C: 0x01CD,
+	0x0061030C: 0x01CE,
+	0x0049030C: 0x01CF,
+	0x0069030C: 0x01D0,
+	0x004F030C: 0x01D1,
+	0x006F030C: 0x01D2,
+	0x0055030C: 0x01D3,
+	0x0075030C: 0x01D4,
+	0x00DC0304: 0x01D5,
+	0x00FC0304: 0x01D6,
+	0x00DC0301: 0x01D7,
+	0x00FC0301: 0x01D8,
+	0x00DC030C: 0x01D9,
+	0x00FC030C: 0x01DA,
+	0x00DC0300: 0x01DB,
+	0x00FC0300: 0x01DC,
+	0x00C40304: 0x01DE,
+	0x00E40304: 0x01DF,
+	0x02260304: 0x01E0,
+	0x02270304: 0x01E1,
+	0x00C60304: 0x01E2,
+	0x00E60304: 0x01E3,
+	0x0047030C: 0x01E6,
+	0x0067030C: 0x01E7,
+	0x004B030C: 0x01E8,
+	0x006B030C: 0x01E9,
+	0x004F0328: 0x01EA,
+	0x006F0328: 0x01EB,
+	0x01EA0304: 0x01EC,
+	0x01EB0304: 0x01ED,
+	0x01B7030C: 0x01EE,
+	0x0292030C: 0x01EF,
+	0x006A030C: 0x01F0,
+	0x00470301: 0x01F4,
+	0x00670301: 0x01F5,
+	0x004E0300: 0x01F8,
+	0x006E0300: 0x01F9,
+	0x00C50301: 0x01FA,
+	0x00E50301: 0x01FB,
+	0x00C60301: 0x01FC,
+	0x00E60301: 0x01FD,
+	0x00D80301: 0x01FE,
+	0x00F80301: 0x01FF,
+	0x0041030F: 0x0200,
+	0x0061030F: 0x0201,
+	0x00410311: 0x0202,
+	0x00610311: 0x0203,
+	0x0045030F: 0x0204,
+	0x0065030F: 0x0205,
+	0x00450311: 0x0206,
+	0x00650311: 0x0207,
+	0x0049030F: 0x0208,
+	0x0069030F: 0x0209,
+	0x00490311: 0x020A,
+	0x00690311: 0x020B,
+	0x004F030F: 0x020C,
+	0x006F030F: 0x020D,
+	0x004F0311: 0x020E,
+	0x006F0311: 0x020F,
+	0x0052030F: 0x0210,
+	0x0072030F: 0x0211,
+	0x00520311: 0x0212,
+	0x00720311: 0x0213,
+	0x0055030F: 0x0214,
+	0x0075030F: 0x0215,
+	0x00550311: 0x0216,
+	0x00750311: 0x0217,
+	0x00530326: 0x0218,
+	0x00730326: 0x0219,
+	0x00540326: 0x021A,
+	0x00740326: 0x021B,
+	0x0048030C: 0x021E,
+	0x0068030C: 0x021F,
+	0x00410307: 0x0226,
+	0x00610307: 0x0227,
+	0x00450327: 0x0228,
+	0x00650327: 0x0229,
+	0x00D60304: 0x022A,
+	0x00F60304: 0x022B,
+	0x00D50304: 0x022C,
+	0x00F50304: 0x022D,
+	0x004F0307: 0x022E,
+	0x006F0307: 0x022F,
+	0x022E0304: 0x0230,
+	0x022F0304: 0x0231,
+	0x00590304: 0x0232,
+	0x00790304: 0x0233,
+	0x00A80301: 0x0385,
+	0x03910301: 0x0386,
+	0x03950301: 0x0388,
+	0x03970301: 0x0389,
+	0x03990301: 0x038A,
+	0x039F0301: 0x038C,
+	0x03A50301: 0x038E,
+	0x03A90301: 0x038F,
+	0x03CA0301: 0x0390,
+	0x03990308: 0x03AA,
+	0x03A50308: 0x03AB,
+	0x03B10301: 0x03AC,
+	0x03B50301: 0x03AD,
+	0x03B70301: 0x03AE,
+	0x03B90301: 0x03AF,
+	0x03CB0301: 0x03B0,
+	0x03B90308: 0x03CA,
+	0x03C50308: 0x03CB,
+	0x03BF0301: 0x03CC,
+	0x03C50301: 0x03CD,
+	0x03C90301: 0x03CE,
+	0x03D20301: 0x03D3,
+	0x03D20308: 0x03D4,
+	0x04150300: 0x0400,
+	0x04150308: 0x0401,
+	0x04130301: 0x0403,
+	0x04060308: 0x0407,
+	0x041A0301: 0x040C,
+	0x04180300: 0x040D,
+	0x04230306: 0x040E,
+	0x04180306: 0x0419,
+	0x04380306: 0x0439,
+	0x04350300: 0x0450,
+	0x04350308: 0x0451,
+	0x04330301: 0x0453,
+	0x04560308: 0x0457,
+	0x043A0301: 0x045C,
+	0x04380300: 0x045D,
+	0x04430306: 0x045E,
+	0x0474030F: 0x0476,
+	0x0475030F: 0x0477,
+	0x04160306: 0x04C1,
+	0x04360306: 0x04C2,
+	0x04100306: 0x04D0,
+	0x04300306: 0x04D1,
+	0x04100308: 0x04D2,
+	0x04300308: 0x04D3,
+	0x04150306: 0x04D6,
+	0x04350306: 0x04D7,
+	0x04D80308: 0x04DA,
+	0x04D90308: 0x04DB,
+	0x04160308: 0x04DC,
+	0x04360308: 0x04DD,
+	0x04170308: 0x04DE,
+	0x04370308: 0x04DF,
+	0x04180304: 0x04E2,
+	0x04380304: 0x04E3,
+	0x04180308: 0x04E4,
+	0x04380308: 0x04E5,
+	0x041E0308: 0x04E6,
+	0x043E0308: 0x04E7,
+	0x04E80308: 0x04EA,
+	0x04E90308: 0x04EB,
+	0x042D0308: 0x04EC,
+	0x044D0308: 0x04ED,
+	0x04230304: 0x04EE,
+	0x04430304: 0x04EF,
+	0x04230308: 0x04F0,
+	0x04430308: 0x04F1,
+	0x0423030B: 0x04F2,
+	0x0443030B: 0x04F3,
+	0x04270308: 0x04F4,
+	0x04470308: 0x04F5,
+	0x042B0308: 0x04F8,
+	0x044B0308: 0x04F9,
+	0x06270653: 0x0622,
+	0x06270654: 0x0623,
+	0x06480654: 0x0624,
+	0x06270655: 0x0625,
+	0x064A0654: 0x0626,
+	0x06D50654: 0x06C0,
+	0x06C10654: 0x06C2,
+	0x06D20654: 0x06D3,
+	0x0928093C: 0x0929,
+	0x0930093C: 0x0931,
+	0x0933093C: 0x0934,
+	0x09C709BE: 0x09CB,
+	0x09C709D7: 0x09CC,
+	0x0B470B56: 0x0B48,
+	0x0B470B3E: 0x0B4B,
+	0x0B470B57: 0x0B4C,
+	0x0B920BD7: 0x0B94,
+	0x0BC60BBE: 0x0BCA,
+	0x0BC70BBE: 0x0BCB,
+	0x0BC60BD7: 0x0BCC,
+	0x0C460C56: 0x0C48,
+	0x0CBF0CD5: 0x0CC0,
+	0x0CC60CD5: 0x0CC7,
+	0x0CC60CD6: 0x0CC8,
+	0x0CC60CC2: 0x0CCA,
+	0x0CCA0CD5: 0x0CCB,
+	0x0D460D3E: 0x0D4A,
+	0x0D470D3E: 0x0D4B,
+	0x0D460D57: 0x0D4C,
+	0x0DD90DCA: 0x0DDA,
+	0x0DD90DCF: 0x0DDC,
+	0x0DDC0DCA: 0x0DDD,
+	0x0DD90DDF: 0x0DDE,
+	0x1025102E: 0x1026,
+	0x1B051B35: 0x1B06,
+	0x1B071B35: 0x1B08,
+	0x1B091B35: 0x1B0A,
+	0x1B0B1B35: 0x1B0C,
+	0x1B0D1B35: 0x1B0E,
+	0x1B111B35: 0x1B12,
+	0x1B3A1B35: 0x1B3B,
+	0x1B3C1B35: 0x1B3D,
+	0x1B3E1B35: 0x1B40,
+	0x1B3F1B35: 0x1B41,
+	0x1B421B35: 0x1B43,
+	0x00410325: 0x1E00,
+	0x00610325: 0x1E01,
+	0x00420307: 0x1E02,
+	0x00620307: 0x1E03,
+	0x00420323: 0x1E04,
+	0x00620323: 0x1E05,
+	0x00420331: 0x1E06,
+	0x00620331: 0x1E07,
+	0x00C70301: 0x1E08,
+	0x00E70301: 0x1E09,
+	0x00440307: 0x1E0A,
+	0x00640307: 0x1E0B,
+	0x00440323: 0x1E0C,
+	0x00640323: 0x1E0D,
+	0x00440331: 0x1E0E,
+	0x00640331: 0x1E0F,
+	0x00440327: 0x1E10,
+	0x00640327: 0x1E11,
+	0x0044032D: 0x1E12,
+	0x0064032D: 0x1E13,
+	0x01120300: 0x1E14,
+	0x01130300: 0x1E15,
+	0x01120301: 0x1E16,
+	0x01130301: 0x1E17,
+	0x0045032D: 0x1E18,
+	0x0065032D: 0x1E19,
+	0x00450330: 0x1E1A,
+	0x00650330: 0x1E1B,
+	0x02280306: 0x1E1C,
+	0x02290306: 0x1E1D,
+	0x00460307: 0x1E1E,
+	0x00660307: 0x1E1F,
+	0x00470304: 0x1E20,
+	0x00670304: 0x1E21,
+	0x00480307: 0x1E22,
+	0x00680307: 0x1E23,
+	0x00480323: 0x1E24,
+	0x00680323: 0x1E25,
+	0x00480308: 0x1E26,
+	0x00680308: 0x1E27,
+	0x00480327: 0x1E28,
+	0x00680327: 0x1E29,
+	0x0048032E: 0x1E2A,
+	0x0068032E: 0x1E2B,
+	0x00490330: 0x1E2C,
+	0x00690330: 0x1E2D,
+	0x00CF0301: 0x1E2E,
+	0x00EF0301: 0x1E2F,
+	0x004B0301: 0x1E30,
+	0x006B0301: 0x1E31,
+	0x004B0323: 0x1E32,
+	0x006B0323: 0x1E33,
+	0x004B0331: 0x1E34,
+	0x006B0331: 0x1E35,
+	0x004C0323: 0x1E36,
+	0x006C0323: 0x1E37,
+	0x1E360304: 0x1E38,
+	0x1E370304: 0x1E39,
+	0x004C0331: 0x1E3A,
+	0x006C0331: 0x1E3B,
+	0x004C032D: 0x1E3C,
+	0x006C032D: 0x1E3D,
+	0x004D0301: 0x1E3E,
+	0x006D0301: 0x1E3F,
+	0x004D0307: 0x1E40,
+	0x006D0307: 0x1E41,
+	0x004D0323: 0x1E42,
+	0x006D0323: 0x1E43,
+	0x004E0307: 0x1E44,
+	0x006E0307: 0x1E45,
+	0x004E0323: 0x1E46,
+	0x006E0323: 0x1E47,
+	0x004E0331: 0x1E48,
+	0x006E0331: 0x1E49,
+	0x004E032D: 0x1E4A,
+	0x006E032D: 0x1E4B,
+	0x00D50301: 0x1E4C,
+	0x00F50301: 0x1E4D,
+	0x00D50308: 0x1E4E,
+	0x00F50308: 0x1E4F,
+	0x014C0300: 0x1E50,
+	0x014D0300: 0x1E51,
+	0x014C0301: 0x1E52,
+	0x014D0301: 0x1E53,
+	0x00500301: 0x1E54,
+	0x00700301: 0x1E55,
+	0x00500307: 0x1E56,
+	0x00700307: 0x1E57,
+	0x00520307: 0x1E58,
+	0x00720307: 0x1E59,
+	0x00520323: 0x1E5A,
+	0x00720323: 0x1E5B,
+	0x1E5A0304: 0x1E5C,
+	0x1E5B0304: 0x1E5D,
+	0x00520331: 0x1E5E,
+	0x00720331: 0x1E5F,
+	0x00530307: 0x1E60,
+	0x00730307: 0x1E61,
+	0x00530323: 0x1E62,
+	0x00730323: 0x1E63,
+	0x015A0307: 0x1E64,
+	0x015B0307: 0x1E65,
+	0x01600307: 0x1E66,
+	0x01610307: 0x1E67,
+	0x1E620307: 0x1E68,
+	0x1E630307: 0x1E69,
+	0x00540307: 0x1E6A,
+	0x00740307: 0x1E6B,
+	0x00540323: 0x1E6C,
+	0x00740323: 0x1E6D,
+	0x00540331: 0x1E6E,
+	0x00740331: 0x1E6F,
+	0x0054032D: 0x1E70,
+	0x0074032D: 0x1E71,
+	0x00550324: 0x1E72,
+	0x00750324: 0x1E73,
+	0x00550330: 0x1E74,
+	0x00750330: 0x1E75,
+	0x0055032D: 0x1E76,
+	0x0075032D: 0x1E77,
+	0x01680301: 0x1E78,
+	0x01690301: 0x1E79,
+	0x016A0308: 0x1E7A,
+	0x016B0308: 0x1E7B,
+	0x00560303: 0x1E7C,
+	0x00760303: 0x1E7D,
+	0x00560323: 0x1E7E,
+	0x00760323: 0x1E7F,
+	0x00570300: 0x1E80,
+	0x00770300: 0x1E81,
+	0x00570301: 0x1E82,
+	0x00770301: 0x1E83,
+	0x00570308: 0x1E84,
+	0x00770308: 0x1E85,
+	0x00570307: 0x1E86,
+	0x00770307: 0x1E87,
+	0x00570323: 0x1E88,
+	0x00770323: 0x1E89,
+	0x00580307: 0x1E8A,
+	0x00780307: 0x1E8B,
+	0x00580308: 0x1E8C,
+	0x00780308: 0x1E8D,
+	0x00590307: 0x1E8E,
+	0x00790307: 0x1E8F,
+	0x005A0302: 0x1E90,
+	0x007A0302: 0x1E91,
+	0x005A0323: 0x1E92,
+	0x007A0323: 0x1E93,
+	0x005A0331: 0x1E94,
+	0x007A0331: 0x1E95,
+	0x00680331: 0x1E96,
+	0x00740308: 0x1E97,
+	0x0077030A: 0x1E98,
+	0x0079030A: 0x1E99,
+	0x017F0307: 0x1E9B,
+	0x00410323: 0x1EA0,
+	0x00610323: 0x1EA1,
+	0x00410309: 0x1EA2,
+	0x00610309: 0x1EA3,
+	0x00C20301: 0x1EA4,
+	0x00E20301: 0x1EA5,
+	0x00C20300: 0x1EA6,
+	0x00E20300: 0x1EA7,
+	0x00C20309: 0x1EA8,
+	0x00E20309: 0x1EA9,
+	0x00C20303: 0x1EAA,
+	0x00E20303: 0x1EAB,
+	0x1EA00302: 0x1EAC,
+	0x1EA10302: 0x1EAD,
+	0x01020301: 0x1EAE,
+	0x01030301: 0x1EAF,
+	0x01020300: 0x1EB0,
+	0x01030300: 0x1EB1,
+	0x01020309: 0x1EB2,
+	0x01030309: 0x1EB3,
+	0x01020303: 0x1EB4,
+	0x01030303: 0x1EB5,
+	0x1EA00306: 0x1EB6,
+	0x1EA10306: 0x1EB7,
+	0x00450323: 0x1EB8,
+	0x00650323: 0x1EB9,
+	0x00450309: 0x1EBA,
+	0x00650309: 0x1EBB,
+	0x00450303: 0x1EBC,
+	0x00650303: 0x1EBD,
+	0x00CA0301: 0x1EBE,
+	0x00EA0301: 0x1EBF,
+	0x00CA0300: 0x1EC0,
+	0x00EA0300: 0x1EC1,
+	0x00CA0309: 0x1EC2,
+	0x00EA0309: 0x1EC3,
+	0x00CA0303: 0x1EC4,
+	0x00EA0303: 0x1EC5,
+	0x1EB80302: 0x1EC6,
+	0x1EB90302: 0x1EC7,
+	0x00490309: 0x1EC8,
+	0x00690309: 0x1EC9,
+	0x00490323: 0x1ECA,
+	0x00690323: 0x1ECB,
+	0x004F0323: 0x1ECC,
+	0x006F0323: 0x1ECD,
+	0x004F0309: 0x1ECE,
+	0x006F0309: 0x1ECF,
+	0x00D40301: 0x1ED0,
+	0x00F40301: 0x1ED1,
+	0x00D40300: 0x1ED2,
+	0x00F40300: 0x1ED3,
+	0x00D40309: 0x1ED4,
+	0x00F40309: 0x1ED5,
+	0x00D40303: 0x1ED6,
+	0x00F40303: 0x1ED7,
+	0x1ECC0302: 0x1ED8,
+	0x1ECD0302: 0x1ED9,
+	0x01A00301: 0x1EDA,
+	0x01A10301: 0x1EDB,
+	0x01A00300: 0x1EDC,
+	0x01A10300: 0x1EDD,
+	0x01A00309: 0x1EDE,
+	0x01A10309: 0x1EDF,
+	0x01A00303: 0x1EE0,
+	0x01A10303: 0x1EE1,
+	0x01A00323: 0x1EE2,
+	0x01A10323: 0x1EE3,
+	0x00550323: 0x1EE4,
+	0x00750323: 0x1EE5,
+	0x00550309: 0x1EE6,
+	0x00750309: 0x1EE7,
+	0x01AF0301: 0x1EE8,
+	0x01B00301: 0x1EE9,
+	0x01AF0300: 0x1EEA,
+	0x01B00300: 0x1EEB,
+	0x01AF0309: 0x1EEC,
+	0x01B00309: 0x1EED,
+	0x01AF0303: 0x1EEE,
+	0x01B00303: 0x1EEF,
+	0x01AF0323: 0x1EF0,
+	0x01B00323: 0x1EF1,
+	0x00590300: 0x1EF2,
+	0x00790300: 0x1EF3,
+	0x00590323: 0x1EF4,
+	0x00790323: 0x1EF5,
+	0x00590309: 0x1EF6,
+	0x00790309: 0x1EF7,
+	0x00590303: 0x1EF8,
+	0x00790303: 0x1EF9,
+	0x03B10313: 0x1F00,
+	0x03B10314: 0x1F01,
+	0x1F000300: 0x1F02,
+	0x1F010300: 0x1F03,
+	0x1F000301: 0x1F04,
+	0x1F010301: 0x1F05,
+	0x1F000342: 0x1F06,
+	0x1F010342: 0x1F07,
+	0x03910313: 0x1F08,
+	0x03910314: 0x1F09,
+	0x1F080300: 0x1F0A,
+	0x1F090300: 0x1F0B,
+	0x1F080301: 0x1F0C,
+	0x1F090301: 0x1F0D,
+	0x1F080342: 0x1F0E,
+	0x1F090342: 0x1F0F,
+	0x03B50313: 0x1F10,
+	0x03B50314: 0x1F11,
+	0x1F100300: 0x1F12,
+	0x1F110300: 0x1F13,
+	0x1F100301: 0x1F14,
+	0x1F110301: 0x1F15,
+	0x03950313: 0x1F18,
+	0x03950314: 0x1F19,
+	0x1F180300: 0x1F1A,
+	0x1F190300: 0x1F1B,
+	0x1F180301: 0x1F1C,
+	0x1F190301: 0x1F1D,
+	0x03B70313: 0x1F20,
+	0x03B70314: 0x1F21,
+	0x1F200300: 0x1F22,
+	0x1F210300: 0x1F23,
+	0x1F200301: 0x1F24,
+	0x1F210301: 0x1F25,
+	0x1F200342: 0x1F26,
+	0x1F210342: 0x1F27,
+	0x03970313: 0x1F28,
+	0x03970314: 0x1F29,
+	0x1F280300: 0x1F2A,
+	0x1F290300: 0x1F2B,
+	0x1F280301: 0x1F2C,
+	0x1F290301: 0x1F2D,
+	0x1F280342: 0x1F2E,
+	0x1F290342: 0x1F2F,
+	0x03B90313: 0x1F30,
+	0x03B90314: 0x1F31,
+	0x1F300300: 0x1F32,
+	0x1F310300: 0x1F33,
+	0x1F300301: 0x1F34,
+	0x1F310301: 0x1F35,
+	0x1F300342: 0x1F36,
+	0x1F310342: 0x1F37,
+	0x03990313: 0x1F38,
+	0x03990314: 0x1F39,
+	0x1F380300: 0x1F3A,
+	0x1F390300: 0x1F3B,
+	0x1F380301: 0x1F3C,
+	0x1F390301: 0x1F3D,
+	0x1F380342: 0x1F3E,
+	0x1F390342: 0x1F3F,
+	0x03BF0313: 0x1F40,
+	0x03BF0314: 0x1F41,
+	0x1F400300: 0x1F42,
+	0x1F410300: 0x1F43,
+	0x1F400301: 0x1F44,
+	0x1F410301: 0x1F45,
+	0x039F0313: 0x1F48,
+	0x039F0314: 0x1F49,
+	0x1F480300: 0x1F4A,
+	0x1F490300: 0x1F4B,
+	0x1F480301: 0x1F4C,
+	0x1F490301: 0x1F4D,
+	0x03C50313: 0x1F50,
+	0x03C50314: 0x1F51,
+	0x1F500300: 0x1F52,
+	0x1F510300: 0x1F53,
+	0x1F500301: 0x1F54,
+	0x1F510301: 0x1F55,
+	0x1F500342: 0x1F56,
+	0x1F510342: 0x1F57,
+	0x03A50314: 0x1F59,
+	0x1F590300: 0x1F5B,
+	0x1F590301: 0x1F5D,
+	0x1F590342: 0x1F5F,
+	0x03C90313: 0x1F60,
+	0x03C90314: 0x1F61,
+	0x1F600300: 0x1F62,
+	0x1F610300: 0x1F63,
+	0x1F600301: 0x1F64,
+	0x1F610301: 0x1F65,
+	0x1F600342: 0x1F66,
+	0x1F610342: 0x1F67,
+	0x03A90313: 0x1F68,
+	0x03A90314: 0x1F69,
+	0x1F680300: 0x1F6A,
+	0x1F690300: 0x1F6B,
+	0x1F680301: 0x1F6C,
+	0x1F690301: 0x1F6D,
+	0x1F680342: 0x1F6E,
+	0x1F690342: 0x1F6F,
+	0x03B10300: 0x1F70,
+	0x03B50300: 0x1F72,
+	0x03B70300: 0x1F74,
+	0x03B90300: 0x1F76,
+	0x03BF0300: 0x1F78,
+	0x03C50300: 0x1F7A,
+	0x03C90300: 0x1F7C,
+	0x1F000345: 0x1F80,
+	0x1F010345: 0x1F81,
+	0x1F020345: 0x1F82,
+	0x1F030345: 0x1F83,
+	0x1F040345: 0x1F84,
+	0x1F050345: 0x1F85,
+	0x1F060345: 0x1F86,
+	0x1F070345: 0x1F87,
+	0x1F080345: 0x1F88,
+	0x1F090345: 0x1F89,
+	0x1F0A0345: 0x1F8A,
+	0x1F0B0345: 0x1F8B,
+	0x1F0C0345: 0x1F8C,
+	0x1F0D0345: 0x1F8D,
+	0x1F0E0345: 0x1F8E,
+	0x1F0F0345: 0x1F8F,
+	0x1F200345: 0x1F90,
+	0x1F210345: 0x1F91,
+	0x1F220345: 0x1F92,
+	0x1F230345: 0x1F93,
+	0x1F240345: 0x1F94,
+	0x1F250345: 0x1F95,
+	0x1F260345: 0x1F96,
+	0x1F270345: 0x1F97,
+	0x1F280345: 0x1F98,
+	0x1F290345: 0x1F99,
+	0x1F2A0345: 0x1F9A,
+	0x1F2B0345: 0x1F9B,
+	0x1F2C0345: 0x1F9C,
+	0x1F2D0345: 0x1F9D,
+	0x1F2E0345: 0x1F9E,
+	0x1F2F0345: 0x1F9F,
+	0x1F600345: 0x1FA0,
+	0x1F610345: 0x1FA1,
+	0x1F620345: 0x1FA2,
+	0x1F630345: 0x1FA3,
+	0x1F640345: 0x1FA4,
+	0x1F650345: 0x1FA5,
+	0x1F660345: 0x1FA6,
+	0x1F670345: 0x1FA7,
+	0x1F680345: 0x1FA8,
+	0x1F690345: 0x1FA9,
+	0x1F6A0345: 0x1FAA,
+	0x1F6B0345: 0x1FAB,
+	0x1F6C0345: 0x1FAC,
+	0x1F6D0345: 0x1FAD,
+	0x1F6E0345: 0x1FAE,
+	0x1F6F0345: 0x1FAF,
+	0x03B10306: 0x1FB0,
+	0x03B10304: 0x1FB1,
+	0x1F700345: 0x1FB2,
+	0x03B10345: 0x1FB3,
+	0x03AC0345: 0x1FB4,
+	0x03B10342: 0x1FB6,
+	0x1FB60345: 0x1FB7,
+	0x03910306: 0x1FB8,
+	0x03910304: 0x1FB9,
+	0x03910300: 0x1FBA,
+	0x03910345: 0x1FBC,
+	0x00A80342: 0x1FC1,
+	0x1F740345: 0x1FC2,
+	0x03B70345: 0x1FC3,
+	0x03AE0345: 0x1FC4,
+	0x03B70342: 0x1FC6,
+	0x1FC60345: 0x1FC7,
+	0x03950300: 0x1FC8,
+	0x03970300: 0x1FCA,
+	0x03970345: 0x1FCC,
+	0x1FBF0300: 0x1FCD,
+	0x1FBF0301: 0x1FCE,
+	0x1FBF0342: 0x1FCF,
+	0x03B90306: 0x1FD0,
+	0x03B90304: 0x1FD1,
+	0x03CA0300: 0x1FD2,
+	0x03B90342: 0x1FD6,
+	0x03CA0342: 0x1FD7,
+	0x03990306: 0x1FD8,
+	0x03990304: 0x1FD9,
+	0x03990300: 0x1FDA,
+	0x1FFE0300: 0x1FDD,
+	0x1FFE0301: 0x1FDE,
+	0x1FFE0342: 0x1FDF,
+	0x03C50306: 0x1FE0,
+	0x03C50304: 0x1FE1,
+	0x03CB0300: 0x1FE2,
+	0x03C10313: 0x1FE4,
+	0x03C10314: 0x1FE5,
+	0x03C50342: 0x1FE6,
+	0x03CB0342: 0x1FE7,
+	0x03A50306: 0x1FE8,
+	0x03A50304: 0x1FE9,
+	0x03A50300: 0x1FEA,
+	0x03A10314: 0x1FEC,
+	0x00A80300: 0x1FED,
+	0x1F7C0345: 0x1FF2,
+	0x03C90345: 0x1FF3,
+	0x03CE0345: 0x1FF4,
+	0x03C90342: 0x1FF6,
+	0x1FF60345: 0x1FF7,
+	0x039F0300: 0x1FF8,
+	0x03A90300: 0x1FFA,
+	0x03A90345: 0x1FFC,
+	0x21900338: 0x219A,
+	0x21920338: 0x219B,
+	0x21940338: 0x21AE,
+	0x21D00338: 0x21CD,
+	0x21D40338: 0x21CE,
+	0x21D20338: 0x21CF,
+	0x22030338: 0x2204,
+	0x22080338: 0x2209,
+	0x220B0338: 0x220C,
+	0x22230338: 0x2224,
+	0x22250338: 0x2226,
+	0x223C0338: 0x2241,
+	0x22430338: 0x2244,
+	0x22450338: 0x2247,
+	0x22480338: 0x2249,
+	0x003D0338: 0x2260,
+	0x22610338: 0x2262,
+	0x224D0338: 0x226D,
+	0x003C0338: 0x226E,
+	0x003E0338: 0x226F,
+	0x22640338: 0x2270,
+	0x22650338: 0x2271,
+	0x22720338: 0x2274,
+	0x22730338: 0x2275,
+	0x22760338: 0x2278,
+	0x22770338: 0x2279,
+	0x227A0338: 0x2280,
+	0x227B0338: 0x2281,
+	0x22820338: 0x2284,
+	0x22830338: 0x2285,
+	0x22860338: 0x2288,
+	0x22870338: 0x2289,
+	0x22A20338: 0x22AC,
+	0x22A80338: 0x22AD,
+	0x22A90338: 0x22AE,
+	0x22AB0338: 0x22AF,
+	0x227C0338: 0x22E0,
+	0x227D0338: 0x22E1,
+	0x22910338: 0x22E2,
+	0x22920338: 0x22E3,
+	0x22B20338: 0x22EA,
+	0x22B30338: 0x22EB,
+	0x22B40338: 0x22EC,
+	0x22B50338: 0x22ED,
+	0x304B3099: 0x304C,
+	0x304D3099: 0x304E,
+	0x304F3099: 0x3050,
+	0x30513099: 0x3052,
+	0x30533099: 0x3054,
+	0x30553099: 0x3056,
+	0x30573099: 0x3058,
+	0x30593099: 0x305A,
+	0x305B3099: 0x305C,
+	0x305D3099: 0x305E,
+	0x305F3099: 0x3060,
+	0x30613099: 0x3062,
+	0x30643099: 0x3065,
+	0x30663099: 0x3067,
+	0x30683099: 0x3069,
+	0x306F3099: 0x3070,
+	0x306F309A: 0x3071,
+	0x30723099: 0x3073,
+	0x3072309A: 0x3074,
+	0x30753099: 0x3076,
+	0x3075309A: 0x3077,
+	0x30783099: 0x3079,
+	0x3078309A: 0x307A,
+	0x307B3099: 0x307C,
+	0x307B309A: 0x307D,
+	0x30463099: 0x3094,
+	0x309D3099: 0x309E,
+	0x30AB3099: 0x30AC,
+	0x30AD3099: 0x30AE,
+	0x30AF3099: 0x30B0,
+	0x30B13099: 0x30B2,
+	0x30B33099: 0x30B4,
+	0x30B53099: 0x30B6,
+	0x30B73099: 0x30B8,
+	0x30B93099: 0x30BA,
+	0x30BB3099: 0x30BC,
+	0x30BD3099: 0x30BE,
+	0x30BF3099: 0x30C0,
+	0x30C13099: 0x30C2,
+	0x30C43099: 0x30C5,
+	0x30C63099: 0x30C7,
+	0x30C83099: 0x30C9,
+	0x30CF3099: 0x30D0,
+	0x30CF309A: 0x30D1,
+	0x30D23099: 0x30D3,
+	0x30D2309A: 0x30D4,
+	0x30D53099: 0x30D6,
+	0x30D5309A: 0x30D7,
+	0x30D83099: 0x30D9,
+	0x30D8309A: 0x30DA,
+	0x30DB3099: 0x30DC,
+	0x30DB309A: 0x30DD,
+	0x30A63099: 0x30F4,
+	0x30EF3099: 0x30F7,
+	0x30F03099: 0x30F8,
+	0x30F13099: 0x30F9,
+	0x30F23099: 0x30FA,
+	0x30FD3099: 0x30FE,
+	0x109910BA: 0x1109A,
+	0x109B10BA: 0x1109C,
+	0x10A510BA: 0x110AB,
+	0x11311127: 0x1112E,
+	0x11321127: 0x1112F,
+	0x1347133E: 0x1134B,
+	0x13471357: 0x1134C,
+	0x14B914BA: 0x114BB,
+	0x14B914B0: 0x114BC,
+	0x14B914BD: 0x114BE,
+	0x15B815AF: 0x115BA,
+	0x15B915AF: 0x115BB,
+}
+
+// Total size of tables: 53KB (54226 bytes)
diff --git a/vendor/golang.org/x/text/unicode/norm/transform.go b/vendor/golang.org/x/text/unicode/norm/transform.go
new file mode 100644
index 000000000..9f47efbaf
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/transform.go
@@ -0,0 +1,88 @@
+// Copyright 2013 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+import (
+	"unicode/utf8"
+
+	"golang.org/x/text/transform"
+)
+
+// Reset implements the Reset method of the transform.Transformer interface.
+func (Form) Reset() {}
+
+// Transform implements the Transform method of the transform.Transformer
+// interface. It may need to write segments of up to MaxSegmentSize at once.
+// Users should either catch ErrShortDst and allow dst to grow or have dst be at
+// least of size MaxTransformChunkSize to be guaranteed of progress.
+func (f Form) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	n := 0
+	// Cap the maximum number of src bytes to check.
+	b := src
+	eof := atEOF
+	if ns := len(dst); ns < len(b) {
+		err = transform.ErrShortDst
+		eof = false
+		b = b[:ns]
+	}
+	i, ok := formTable[f].quickSpan(inputBytes(b), n, len(b), eof)
+	n += copy(dst[n:], b[n:i])
+	if !ok {
+		nDst, nSrc, err = f.transform(dst[n:], src[n:], atEOF)
+		return nDst + n, nSrc + n, err
+	}
+	if n < len(src) && !atEOF {
+		err = transform.ErrShortSrc
+	}
+	return n, n, err
+}
+
+func flushTransform(rb *reorderBuffer) bool {
+	// Write out (must fully fit in dst, or else it is an ErrShortDst).
+	if len(rb.out) < rb.nrune*utf8.UTFMax {
+		return false
+	}
+	rb.out = rb.out[rb.flushCopy(rb.out):]
+	return true
+}
+
+var errs = []error{nil, transform.ErrShortDst, transform.ErrShortSrc}
+
+// transform implements the transform.Transformer interface. It is only called
+// when quickSpan does not pass for a given string.
+func (f Form) transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	// TODO: get rid of reorderBuffer. See CL 23460044.
+	rb := reorderBuffer{}
+	rb.init(f, src)
+	for {
+		// Load segment into reorder buffer.
+		rb.setFlusher(dst[nDst:], flushTransform)
+		end := decomposeSegment(&rb, nSrc, atEOF)
+		if end < 0 {
+			return nDst, nSrc, errs[-end]
+		}
+		nDst = len(dst) - len(rb.out)
+		nSrc = end
+
+		// Next quickSpan.
+		end = rb.nsrc
+		eof := atEOF
+		if n := nSrc + len(dst) - nDst; n < end {
+			err = transform.ErrShortDst
+			end = n
+			eof = false
+		}
+		end, ok := rb.f.quickSpan(rb.src, nSrc, end, eof)
+		n := copy(dst[nDst:], rb.src.bytes[nSrc:end])
+		nSrc += n
+		nDst += n
+		if ok {
+			if n < rb.nsrc && !atEOF {
+				err = transform.ErrShortSrc
+			}
+			return nDst, nSrc, err
+		}
+	}
+}
diff --git a/vendor/golang.org/x/text/unicode/norm/trie.go b/vendor/golang.org/x/text/unicode/norm/trie.go
new file mode 100644
index 000000000..423386bf4
--- /dev/null
+++ b/vendor/golang.org/x/text/unicode/norm/trie.go
@@ -0,0 +1,54 @@
+// Copyright 2011 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package norm
+
+type valueRange struct {
+	value  uint16 // header: value:stride
+	lo, hi byte   // header: lo:n
+}
+
+type sparseBlocks struct {
+	values []valueRange
+	offset []uint16
+}
+
+var nfcSparse = sparseBlocks{
+	values: nfcSparseValues[:],
+	offset: nfcSparseOffset[:],
+}
+
+var nfkcSparse = sparseBlocks{
+	values: nfkcSparseValues[:],
+	offset: nfkcSparseOffset[:],
+}
+
+var (
+	nfcData  = newNfcTrie(0)
+	nfkcData = newNfkcTrie(0)
+)
+
+// lookupValue determines the type of block n and looks up the value for b.
+// For n < t.cutoff, the block is a simple lookup table. Otherwise, the block
+// is a list of ranges with an accompanying value. Given a matching range r,
+// the value for b is by r.value + (b - r.lo) * stride.
+func (t *sparseBlocks) lookup(n uint32, b byte) uint16 {
+	offset := t.offset[n]
+	header := t.values[offset]
+	lo := offset + 1
+	hi := lo + uint16(header.lo)
+	for lo < hi {
+		m := lo + (hi-lo)/2
+		r := t.values[m]
+		if r.lo <= b && b <= r.hi {
+			return r.value + uint16(b-r.lo)*header.value
+		}
+		if b < r.lo {
+			hi = m
+		} else {
+			lo = m + 1
+		}
+	}
+	return 0
+}
diff --git a/vendor/google.golang.org/genproto/LICENSE b/vendor/google.golang.org/genproto/LICENSE
new file mode 100644
index 000000000..d64569567
--- /dev/null
+++ b/vendor/google.golang.org/genproto/LICENSE
@@ -0,0 +1,202 @@
+
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/google.golang.org/genproto/googleapis/rpc/status/status.pb.go b/vendor/google.golang.org/genproto/googleapis/rpc/status/status.pb.go
new file mode 100644
index 000000000..8867ae781
--- /dev/null
+++ b/vendor/google.golang.org/genproto/googleapis/rpc/status/status.pb.go
@@ -0,0 +1,143 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: google/rpc/status.proto
+
+/*
+Package status is a generated protocol buffer package.
+
+It is generated from these files:
+	google/rpc/status.proto
+
+It has these top-level messages:
+	Status
+*/
+package status
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+import google_protobuf "github.com/golang/protobuf/ptypes/any"
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+// The `Status` type defines a logical error model that is suitable for different
+// programming environments, including REST APIs and RPC APIs. It is used by
+// [gRPC](https://github.com/grpc). The error model is designed to be:
+//
+// - Simple to use and understand for most users
+// - Flexible enough to meet unexpected needs
+//
+// # Overview
+//
+// The `Status` message contains three pieces of data: error code, error message,
+// and error details. The error code should be an enum value of
+// [google.rpc.Code][google.rpc.Code], but it may accept additional error codes if needed.  The
+// error message should be a developer-facing English message that helps
+// developers *understand* and *resolve* the error. If a localized user-facing
+// error message is needed, put the localized message in the error details or
+// localize it in the client. The optional error details may contain arbitrary
+// information about the error. There is a predefined set of error detail types
+// in the package `google.rpc` that can be used for common error conditions.
+//
+// # Language mapping
+//
+// The `Status` message is the logical representation of the error model, but it
+// is not necessarily the actual wire format. When the `Status` message is
+// exposed in different client libraries and different wire protocols, it can be
+// mapped differently. For example, it will likely be mapped to some exceptions
+// in Java, but more likely mapped to some error codes in C.
+//
+// # Other uses
+//
+// The error model and the `Status` message can be used in a variety of
+// environments, either with or without APIs, to provide a
+// consistent developer experience across different environments.
+//
+// Example uses of this error model include:
+//
+// - Partial errors. If a service needs to return partial errors to the client,
+//     it may embed the `Status` in the normal response to indicate the partial
+//     errors.
+//
+// - Workflow errors. A typical workflow has multiple steps. Each step may
+//     have a `Status` message for error reporting.
+//
+// - Batch operations. If a client uses batch request and batch response, the
+//     `Status` message should be used directly inside batch response, one for
+//     each error sub-response.
+//
+// - Asynchronous operations. If an API call embeds asynchronous operation
+//     results in its response, the status of those operations should be
+//     represented directly using the `Status` message.
+//
+// - Logging. If some API errors are stored in logs, the message `Status` could
+//     be used directly after any stripping needed for security/privacy reasons.
+type Status struct {
+	// The status code, which should be an enum value of [google.rpc.Code][google.rpc.Code].
+	Code int32 `protobuf:"varint,1,opt,name=code" json:"code,omitempty"`
+	// A developer-facing error message, which should be in English. Any
+	// user-facing error message should be localized and sent in the
+	// [google.rpc.Status.details][google.rpc.Status.details] field, or localized by the client.
+	Message string `protobuf:"bytes,2,opt,name=message" json:"message,omitempty"`
+	// A list of messages that carry the error details.  There is a common set of
+	// message types for APIs to use.
+	Details []*google_protobuf.Any `protobuf:"bytes,3,rep,name=details" json:"details,omitempty"`
+}
+
+func (m *Status) Reset()                    { *m = Status{} }
+func (m *Status) String() string            { return proto.CompactTextString(m) }
+func (*Status) ProtoMessage()               {}
+func (*Status) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *Status) GetCode() int32 {
+	if m != nil {
+		return m.Code
+	}
+	return 0
+}
+
+func (m *Status) GetMessage() string {
+	if m != nil {
+		return m.Message
+	}
+	return ""
+}
+
+func (m *Status) GetDetails() []*google_protobuf.Any {
+	if m != nil {
+		return m.Details
+	}
+	return nil
+}
+
+func init() {
+	proto.RegisterType((*Status)(nil), "google.rpc.Status")
+}
+
+func init() { proto.RegisterFile("google/rpc/status.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 209 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x12, 0x4f, 0xcf, 0xcf, 0x4f,
+	0xcf, 0x49, 0xd5, 0x2f, 0x2a, 0x48, 0xd6, 0x2f, 0x2e, 0x49, 0x2c, 0x29, 0x2d, 0xd6, 0x2b, 0x28,
+	0xca, 0x2f, 0xc9, 0x17, 0xe2, 0x82, 0x48, 0xe8, 0x15, 0x15, 0x24, 0x4b, 0x49, 0x42, 0x15, 0x81,
+	0x65, 0x92, 0x4a, 0xd3, 0xf4, 0x13, 0xf3, 0x2a, 0x21, 0xca, 0x94, 0xd2, 0xb8, 0xd8, 0x82, 0xc1,
+	0xda, 0x84, 0x84, 0xb8, 0x58, 0x92, 0xf3, 0x53, 0x52, 0x25, 0x18, 0x15, 0x18, 0x35, 0x58, 0x83,
+	0xc0, 0x6c, 0x21, 0x09, 0x2e, 0xf6, 0xdc, 0xd4, 0xe2, 0xe2, 0xc4, 0xf4, 0x54, 0x09, 0x26, 0x05,
+	0x46, 0x0d, 0xce, 0x20, 0x18, 0x57, 0x48, 0x8f, 0x8b, 0x3d, 0x25, 0xb5, 0x24, 0x31, 0x33, 0xa7,
+	0x58, 0x82, 0x59, 0x81, 0x59, 0x83, 0xdb, 0x48, 0x44, 0x0f, 0x6a, 0x21, 0xcc, 0x12, 0x3d, 0xc7,
+	0xbc, 0xca, 0x20, 0x98, 0x22, 0xa7, 0x38, 0x2e, 0xbe, 0xe4, 0xfc, 0x5c, 0x3d, 0x84, 0xa3, 0x9c,
+	0xb8, 0x21, 0xf6, 0x06, 0x80, 0x94, 0x07, 0x30, 0x46, 0x99, 0x43, 0xa5, 0xd2, 0xf3, 0x73, 0x12,
+	0xf3, 0xd2, 0xf5, 0xf2, 0x8b, 0xd2, 0xf5, 0xd3, 0x53, 0xf3, 0xc0, 0x86, 0xe9, 0x43, 0xa4, 0x12,
+	0x0b, 0x32, 0x8b, 0x91, 0xfc, 0x69, 0x0d, 0xa1, 0x16, 0x31, 0x31, 0x07, 0x05, 0x38, 0x27, 0xb1,
+	0x81, 0x55, 0x1a, 0x03, 0x02, 0x00, 0x00, 0xff, 0xff, 0xa4, 0x53, 0xf0, 0x7c, 0x10, 0x01, 0x00,
+	0x00,
+}
diff --git a/vendor/google.golang.org/grpc/LICENSE b/vendor/google.golang.org/grpc/LICENSE
index f4988b450..d64569567 100644
--- a/vendor/google.golang.org/grpc/LICENSE
+++ b/vendor/google.golang.org/grpc/LICENSE
@@ -1,28 +1,202 @@
-Copyright 2014, Google Inc.
-All rights reserved.
 
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
 
-    * Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-    * Redistributions in binary form must reproduce the above
-copyright notice, this list of conditions and the following disclaimer
-in the documentation and/or other materials provided with the
-distribution.
-    * Neither the name of Google Inc. nor the names of its
-contributors may be used to endorse or promote products derived from
-this software without specific prior written permission.
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
 
-THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
-"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
-LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
-A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
-OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
-SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
-LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
-DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
-THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
-(INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
-OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   APPENDIX: How to apply the Apache License to your work.
+
+      To apply the Apache License to your work, attach the following
+      boilerplate notice, with the fields enclosed by brackets "[]"
+      replaced with your own identifying information. (Don't include
+      the brackets!)  The text should be enclosed in the appropriate
+      comment syntax for the file format. We also recommend that a
+      file or class name and description of purpose be included on the
+      same "printed page" as the copyright notice for easier
+      identification within third-party archives.
+
+   Copyright [yyyy] [name of copyright owner]
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.
diff --git a/vendor/google.golang.org/grpc/health/grpc_health_v1/health.pb.go b/vendor/google.golang.org/grpc/health/grpc_health_v1/health.pb.go
new file mode 100644
index 000000000..fdcbb9e0b
--- /dev/null
+++ b/vendor/google.golang.org/grpc/health/grpc_health_v1/health.pb.go
@@ -0,0 +1,190 @@
+// Code generated by protoc-gen-go. DO NOT EDIT.
+// source: grpc_health_v1/health.proto
+
+/*
+Package grpc_health_v1 is a generated protocol buffer package.
+
+It is generated from these files:
+	grpc_health_v1/health.proto
+
+It has these top-level messages:
+	HealthCheckRequest
+	HealthCheckResponse
+*/
+package grpc_health_v1
+
+import proto "github.com/golang/protobuf/proto"
+import fmt "fmt"
+import math "math"
+
+import (
+	context "golang.org/x/net/context"
+	grpc "google.golang.org/grpc"
+)
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ = proto.Marshal
+var _ = fmt.Errorf
+var _ = math.Inf
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the proto package it is being compiled against.
+// A compilation error at this line likely means your copy of the
+// proto package needs to be updated.
+const _ = proto.ProtoPackageIsVersion2 // please upgrade the proto package
+
+type HealthCheckResponse_ServingStatus int32
+
+const (
+	HealthCheckResponse_UNKNOWN     HealthCheckResponse_ServingStatus = 0
+	HealthCheckResponse_SERVING     HealthCheckResponse_ServingStatus = 1
+	HealthCheckResponse_NOT_SERVING HealthCheckResponse_ServingStatus = 2
+)
+
+var HealthCheckResponse_ServingStatus_name = map[int32]string{
+	0: "UNKNOWN",
+	1: "SERVING",
+	2: "NOT_SERVING",
+}
+var HealthCheckResponse_ServingStatus_value = map[string]int32{
+	"UNKNOWN":     0,
+	"SERVING":     1,
+	"NOT_SERVING": 2,
+}
+
+func (x HealthCheckResponse_ServingStatus) String() string {
+	return proto.EnumName(HealthCheckResponse_ServingStatus_name, int32(x))
+}
+func (HealthCheckResponse_ServingStatus) EnumDescriptor() ([]byte, []int) {
+	return fileDescriptor0, []int{1, 0}
+}
+
+type HealthCheckRequest struct {
+	Service string `protobuf:"bytes,1,opt,name=service" json:"service,omitempty"`
+}
+
+func (m *HealthCheckRequest) Reset()                    { *m = HealthCheckRequest{} }
+func (m *HealthCheckRequest) String() string            { return proto.CompactTextString(m) }
+func (*HealthCheckRequest) ProtoMessage()               {}
+func (*HealthCheckRequest) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{0} }
+
+func (m *HealthCheckRequest) GetService() string {
+	if m != nil {
+		return m.Service
+	}
+	return ""
+}
+
+type HealthCheckResponse struct {
+	Status HealthCheckResponse_ServingStatus `protobuf:"varint,1,opt,name=status,enum=grpc.health.v1.HealthCheckResponse_ServingStatus" json:"status,omitempty"`
+}
+
+func (m *HealthCheckResponse) Reset()                    { *m = HealthCheckResponse{} }
+func (m *HealthCheckResponse) String() string            { return proto.CompactTextString(m) }
+func (*HealthCheckResponse) ProtoMessage()               {}
+func (*HealthCheckResponse) Descriptor() ([]byte, []int) { return fileDescriptor0, []int{1} }
+
+func (m *HealthCheckResponse) GetStatus() HealthCheckResponse_ServingStatus {
+	if m != nil {
+		return m.Status
+	}
+	return HealthCheckResponse_UNKNOWN
+}
+
+func init() {
+	proto.RegisterType((*HealthCheckRequest)(nil), "grpc.health.v1.HealthCheckRequest")
+	proto.RegisterType((*HealthCheckResponse)(nil), "grpc.health.v1.HealthCheckResponse")
+	proto.RegisterEnum("grpc.health.v1.HealthCheckResponse_ServingStatus", HealthCheckResponse_ServingStatus_name, HealthCheckResponse_ServingStatus_value)
+}
+
+// Reference imports to suppress errors if they are not otherwise used.
+var _ context.Context
+var _ grpc.ClientConn
+
+// This is a compile-time assertion to ensure that this generated file
+// is compatible with the grpc package it is being compiled against.
+const _ = grpc.SupportPackageIsVersion4
+
+// Client API for Health service
+
+type HealthClient interface {
+	Check(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (*HealthCheckResponse, error)
+}
+
+type healthClient struct {
+	cc *grpc.ClientConn
+}
+
+func NewHealthClient(cc *grpc.ClientConn) HealthClient {
+	return &healthClient{cc}
+}
+
+func (c *healthClient) Check(ctx context.Context, in *HealthCheckRequest, opts ...grpc.CallOption) (*HealthCheckResponse, error) {
+	out := new(HealthCheckResponse)
+	err := grpc.Invoke(ctx, "/grpc.health.v1.Health/Check", in, out, c.cc, opts...)
+	if err != nil {
+		return nil, err
+	}
+	return out, nil
+}
+
+// Server API for Health service
+
+type HealthServer interface {
+	Check(context.Context, *HealthCheckRequest) (*HealthCheckResponse, error)
+}
+
+func RegisterHealthServer(s *grpc.Server, srv HealthServer) {
+	s.RegisterService(&_Health_serviceDesc, srv)
+}
+
+func _Health_Check_Handler(srv interface{}, ctx context.Context, dec func(interface{}) error, interceptor grpc.UnaryServerInterceptor) (interface{}, error) {
+	in := new(HealthCheckRequest)
+	if err := dec(in); err != nil {
+		return nil, err
+	}
+	if interceptor == nil {
+		return srv.(HealthServer).Check(ctx, in)
+	}
+	info := &grpc.UnaryServerInfo{
+		Server:     srv,
+		FullMethod: "/grpc.health.v1.Health/Check",
+	}
+	handler := func(ctx context.Context, req interface{}) (interface{}, error) {
+		return srv.(HealthServer).Check(ctx, req.(*HealthCheckRequest))
+	}
+	return interceptor(ctx, in, info, handler)
+}
+
+var _Health_serviceDesc = grpc.ServiceDesc{
+	ServiceName: "grpc.health.v1.Health",
+	HandlerType: (*HealthServer)(nil),
+	Methods: []grpc.MethodDesc{
+		{
+			MethodName: "Check",
+			Handler:    _Health_Check_Handler,
+		},
+	},
+	Streams:  []grpc.StreamDesc{},
+	Metadata: "grpc_health_v1/health.proto",
+}
+
+func init() { proto.RegisterFile("grpc_health_v1/health.proto", fileDescriptor0) }
+
+var fileDescriptor0 = []byte{
+	// 213 bytes of a gzipped FileDescriptorProto
+	0x1f, 0x8b, 0x08, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02, 0xff, 0xe2, 0x92, 0x4e, 0x2f, 0x2a, 0x48,
+	0x8e, 0xcf, 0x48, 0x4d, 0xcc, 0x29, 0xc9, 0x88, 0x2f, 0x33, 0xd4, 0x87, 0xb0, 0xf4, 0x0a, 0x8a,
+	0xf2, 0x4b, 0xf2, 0x85, 0xf8, 0x40, 0x92, 0x7a, 0x50, 0xa1, 0x32, 0x43, 0x25, 0x3d, 0x2e, 0x21,
+	0x0f, 0x30, 0xc7, 0x39, 0x23, 0x35, 0x39, 0x3b, 0x28, 0xb5, 0xb0, 0x34, 0xb5, 0xb8, 0x44, 0x48,
+	0x82, 0x8b, 0xbd, 0x38, 0xb5, 0xa8, 0x2c, 0x33, 0x39, 0x55, 0x82, 0x51, 0x81, 0x51, 0x83, 0x33,
+	0x08, 0xc6, 0x55, 0x9a, 0xc3, 0xc8, 0x25, 0x8c, 0xa2, 0xa1, 0xb8, 0x20, 0x3f, 0xaf, 0x38, 0x55,
+	0xc8, 0x93, 0x8b, 0xad, 0xb8, 0x24, 0xb1, 0xa4, 0xb4, 0x18, 0xac, 0x81, 0xcf, 0xc8, 0x50, 0x0f,
+	0xd5, 0x22, 0x3d, 0x2c, 0x9a, 0xf4, 0x82, 0x41, 0x86, 0xe6, 0xa5, 0x07, 0x83, 0x35, 0x06, 0x41,
+	0x0d, 0x50, 0xb2, 0xe2, 0xe2, 0x45, 0x91, 0x10, 0xe2, 0xe6, 0x62, 0x0f, 0xf5, 0xf3, 0xf6, 0xf3,
+	0x0f, 0xf7, 0x13, 0x60, 0x00, 0x71, 0x82, 0x5d, 0x83, 0xc2, 0x3c, 0xfd, 0xdc, 0x05, 0x18, 0x85,
+	0xf8, 0xb9, 0xb8, 0xfd, 0xfc, 0x43, 0xe2, 0x61, 0x02, 0x4c, 0x46, 0x51, 0x5c, 0x6c, 0x10, 0x8b,
+	0x84, 0x02, 0xb8, 0x58, 0xc1, 0x96, 0x09, 0x29, 0xe1, 0x75, 0x09, 0xd8, 0xbf, 0x52, 0xca, 0x44,
+	0xb8, 0x36, 0x89, 0x0d, 0x1c, 0x82, 0xc6, 0x80, 0x00, 0x00, 0x00, 0xff, 0xff, 0x53, 0x2b, 0x65,
+	0x20, 0x60, 0x01, 0x00, 0x00,
+}
diff --git a/vendor/google.golang.org/grpc/health/grpc_health_v1/health.proto b/vendor/google.golang.org/grpc/health/grpc_health_v1/health.proto
new file mode 100644
index 000000000..6072fdc3b
--- /dev/null
+++ b/vendor/google.golang.org/grpc/health/grpc_health_v1/health.proto
@@ -0,0 +1,34 @@
+// Copyright 2017 gRPC authors.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+syntax = "proto3";
+
+package grpc.health.v1;
+
+message HealthCheckRequest {
+  string service = 1;
+}
+
+message HealthCheckResponse {
+  enum ServingStatus {
+ 	UNKNOWN = 0;
+	SERVING = 1;
+	NOT_SERVING = 2;
+  }
+  ServingStatus status = 1;
+}
+
+service Health{
+  rpc Check(HealthCheckRequest) returns (HealthCheckResponse);
+} 
diff --git a/vendor/google.golang.org/grpc/keepalive/keepalive.go b/vendor/google.golang.org/grpc/keepalive/keepalive.go
new file mode 100644
index 000000000..f8adc7e6d
--- /dev/null
+++ b/vendor/google.golang.org/grpc/keepalive/keepalive.go
@@ -0,0 +1,65 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package keepalive defines configurable parameters for point-to-point healthcheck.
+package keepalive
+
+import (
+	"time"
+)
+
+// ClientParameters is used to set keepalive parameters on the client-side.
+// These configure how the client will actively probe to notice when a connection is broken
+// and send pings so intermediaries will be aware of the liveness of the connection.
+// Make sure these parameters are set in coordination with the keepalive policy on the server,
+// as incompatible settings can result in closing of connection.
+type ClientParameters struct {
+	// After a duration of this time if the client doesn't see any activity it pings the server to see if the transport is still alive.
+	Time time.Duration // The current default value is infinity.
+	// After having pinged for keepalive check, the client waits for a duration of Timeout and if no activity is seen even after that
+	// the connection is closed.
+	Timeout time.Duration // The current default value is 20 seconds.
+	// If true, client runs keepalive checks even with no active RPCs.
+	PermitWithoutStream bool // false by default.
+}
+
+// ServerParameters is used to set keepalive and max-age parameters on the server-side.
+type ServerParameters struct {
+	// MaxConnectionIdle is a duration for the amount of time after which an idle connection would be closed by sending a GoAway.
+	// Idleness duration is defined since the most recent time the number of outstanding RPCs became zero or the connection establishment.
+	MaxConnectionIdle time.Duration // The current default value is infinity.
+	// MaxConnectionAge is a duration for the maximum amount of time a connection may exist before it will be closed by sending a GoAway.
+	// A random jitter of +/-10% will be added to MaxConnectionAge to spread out connection storms.
+	MaxConnectionAge time.Duration // The current default value is infinity.
+	// MaxConnectinoAgeGrace is an additive period after MaxConnectionAge after which the connection will be forcibly closed.
+	MaxConnectionAgeGrace time.Duration // The current default value is infinity.
+	// After a duration of this time if the server doesn't see any activity it pings the client to see if the transport is still alive.
+	Time time.Duration // The current default value is 2 hours.
+	// After having pinged for keepalive check, the server waits for a duration of Timeout and if no activity is seen even after that
+	// the connection is closed.
+	Timeout time.Duration // The current default value is 20 seconds.
+}
+
+// EnforcementPolicy is used to set keepalive enforcement policy on the server-side.
+// Server will close connection with a client that violates this policy.
+type EnforcementPolicy struct {
+	// MinTime is the minimum amount of time a client should wait before sending a keepalive ping.
+	MinTime time.Duration // The current default value is 5 minutes.
+	// If true, server expects keepalive pings even when there are no active streams(RPCs).
+	PermitWithoutStream bool // false by default.
+}
diff --git a/vendor/google.golang.org/grpc/status/status.go b/vendor/google.golang.org/grpc/status/status.go
new file mode 100644
index 000000000..871dc4b31
--- /dev/null
+++ b/vendor/google.golang.org/grpc/status/status.go
@@ -0,0 +1,168 @@
+/*
+ *
+ * Copyright 2017 gRPC authors.
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ *
+ */
+
+// Package status implements errors returned by gRPC.  These errors are
+// serialized and transmitted on the wire between server and client, and allow
+// for additional data to be transmitted via the Details field in the status
+// proto.  gRPC service handlers should return an error created by this
+// package, and gRPC clients should expect a corresponding error to be
+// returned from the RPC call.
+//
+// This package upholds the invariants that a non-nil error may not
+// contain an OK code, and an OK code must result in a nil error.
+package status
+
+import (
+	"errors"
+	"fmt"
+
+	"github.com/golang/protobuf/proto"
+	"github.com/golang/protobuf/ptypes"
+	spb "google.golang.org/genproto/googleapis/rpc/status"
+	"google.golang.org/grpc/codes"
+)
+
+// statusError is an alias of a status proto.  It implements error and Status,
+// and a nil statusError should never be returned by this package.
+type statusError spb.Status
+
+func (se *statusError) Error() string {
+	p := (*spb.Status)(se)
+	return fmt.Sprintf("rpc error: code = %s desc = %s", codes.Code(p.GetCode()), p.GetMessage())
+}
+
+func (se *statusError) status() *Status {
+	return &Status{s: (*spb.Status)(se)}
+}
+
+// Status represents an RPC status code, message, and details.  It is immutable
+// and should be created with New, Newf, or FromProto.
+type Status struct {
+	s *spb.Status
+}
+
+// Code returns the status code contained in s.
+func (s *Status) Code() codes.Code {
+	if s == nil || s.s == nil {
+		return codes.OK
+	}
+	return codes.Code(s.s.Code)
+}
+
+// Message returns the message contained in s.
+func (s *Status) Message() string {
+	if s == nil || s.s == nil {
+		return ""
+	}
+	return s.s.Message
+}
+
+// Proto returns s's status as an spb.Status proto message.
+func (s *Status) Proto() *spb.Status {
+	if s == nil {
+		return nil
+	}
+	return proto.Clone(s.s).(*spb.Status)
+}
+
+// Err returns an immutable error representing s; returns nil if s.Code() is
+// OK.
+func (s *Status) Err() error {
+	if s.Code() == codes.OK {
+		return nil
+	}
+	return (*statusError)(s.s)
+}
+
+// New returns a Status representing c and msg.
+func New(c codes.Code, msg string) *Status {
+	return &Status{s: &spb.Status{Code: int32(c), Message: msg}}
+}
+
+// Newf returns New(c, fmt.Sprintf(format, a...)).
+func Newf(c codes.Code, format string, a ...interface{}) *Status {
+	return New(c, fmt.Sprintf(format, a...))
+}
+
+// Error returns an error representing c and msg.  If c is OK, returns nil.
+func Error(c codes.Code, msg string) error {
+	return New(c, msg).Err()
+}
+
+// Errorf returns Error(c, fmt.Sprintf(format, a...)).
+func Errorf(c codes.Code, format string, a ...interface{}) error {
+	return Error(c, fmt.Sprintf(format, a...))
+}
+
+// ErrorProto returns an error representing s.  If s.Code is OK, returns nil.
+func ErrorProto(s *spb.Status) error {
+	return FromProto(s).Err()
+}
+
+// FromProto returns a Status representing s.
+func FromProto(s *spb.Status) *Status {
+	return &Status{s: proto.Clone(s).(*spb.Status)}
+}
+
+// FromError returns a Status representing err if it was produced from this
+// package, otherwise it returns nil, false.
+func FromError(err error) (s *Status, ok bool) {
+	if err == nil {
+		return &Status{s: &spb.Status{Code: int32(codes.OK)}}, true
+	}
+	if s, ok := err.(*statusError); ok {
+		return s.status(), true
+	}
+	return nil, false
+}
+
+// WithDetails returns a new status with the provided details messages appended to the status.
+// If any errors are encountered, it returns nil and the first error encountered.
+func (s *Status) WithDetails(details ...proto.Message) (*Status, error) {
+	if s.Code() == codes.OK {
+		return nil, errors.New("no error details for status with code OK")
+	}
+	// s.Code() != OK implies that s.Proto() != nil.
+	p := s.Proto()
+	for _, detail := range details {
+		any, err := ptypes.MarshalAny(detail)
+		if err != nil {
+			return nil, err
+		}
+		p.Details = append(p.Details, any)
+	}
+	return &Status{s: p}, nil
+}
+
+// Details returns a slice of details messages attached to the status.
+// If a detail cannot be decoded, the error is returned in place of the detail.
+func (s *Status) Details() []interface{} {
+	if s == nil || s.s == nil {
+		return nil
+	}
+	details := make([]interface{}, 0, len(s.s.Details))
+	for _, any := range s.s.Details {
+		detail := &ptypes.DynamicAny{}
+		if err := ptypes.UnmarshalAny(any, detail); err != nil {
+			details = append(details, err)
+			continue
+		}
+		details = append(details, detail.Message)
+	}
+	return details
+}
diff --git a/vendor/vendor.json b/vendor/vendor.json
index 43fbe4adc..b3874d4de 100644
--- a/vendor/vendor.json
+++ b/vendor/vendor.json
@@ -81,6 +81,12 @@
 			"revision": "28b053d5a2923b87ce8c5a08f3af779894a72758",
 			"revisionTime": "2015-10-08T13:54:07Z"
 		},
+		{
+			"checksumSHA1": "jQh1fnoKPKMURvKkpdRjN695nAQ=",
+			"path": "github.com/agext/levenshtein",
+			"revision": "5f10fee965225ac1eecdc234c09daf5cd9e7f7b6",
+			"revisionTime": "2017-02-17T06:30:20Z"
+		},
 		{
 			"checksumSHA1": "LLVyR2dAgkihu0+HdZF+JK0gMMs=",
 			"path": "github.com/agl/ed25519",
@@ -105,6 +111,12 @@
 			"revision": "f6af74d34d1ef69a511c59173876fc1174c11f0d",
 			"revisionTime": "2016-08-26T14:30:32Z"
 		},
+		{
+			"checksumSHA1": "Ffhtm8iHH7l2ynVVOIGJE3eiuLA=",
+			"path": "github.com/apparentlymart/go-textseg/textseg",
+			"revision": "b836f5c4d331d1945a2fead7188db25432d73b69",
+			"revisionTime": "2017-05-31T20:39:52Z"
+		},
 		{
 			"checksumSHA1": "gNO0JNpLzYOdInGeq7HqMZUzx9M=",
 			"path": "github.com/armon/go-radix",
@@ -797,18 +809,66 @@
 			"revision": "e5527914aa42cae3063f52892e1ca4518da0e4ae",
 			"revisionTime": "2016-01-29T17:01:33Z"
 		},
+		{
+			"checksumSHA1": "7BC2/27NId9xaPDB5w3nWN2mn9A=",
+			"path": "github.com/coreos/etcd/auth/authpb",
+			"revision": "fff1fb2ed7510d569498cad3161f3ec938a0f4d4",
+			"revisionTime": "2017-10-25T00:38:12Z"
+		},
 		{
 			"checksumSHA1": "vHgur8rFMm8ewYO5tqJXXXE/XnA=",
 			"comment": "v2.3.0-alpha.0-652-ge552791",
 			"path": "github.com/coreos/etcd/client",
 			"revision": "e5527914aa42cae3063f52892e1ca4518da0e4ae"
 		},
+		{
+			"checksumSHA1": "4m3qRCZfmTyRSzd4eH8ovMb5OXY=",
+			"path": "github.com/coreos/etcd/clientv3",
+			"revision": "fff1fb2ed7510d569498cad3161f3ec938a0f4d4",
+			"revisionTime": "2017-10-25T00:38:12Z"
+		},
+		{
+			"checksumSHA1": "LpOgTec6cz2Tf3zDav7VkqMHmBM=",
+			"path": "github.com/coreos/etcd/clientv3/concurrency",
+			"revision": "fff1fb2ed7510d569498cad3161f3ec938a0f4d4",
+			"revisionTime": "2017-10-25T00:38:12Z"
+		},
+		{
+			"checksumSHA1": "VMC9J0rMVk3Fv8r8Bj7qqLlXc3E=",
+			"path": "github.com/coreos/etcd/etcdserver/api/v3rpc/rpctypes",
+			"revision": "fff1fb2ed7510d569498cad3161f3ec938a0f4d4",
+			"revisionTime": "2017-10-25T00:38:12Z"
+		},
+		{
+			"checksumSHA1": "c0ltvGUOnk8qaEshFwc0PDH5nbc=",
+			"path": "github.com/coreos/etcd/etcdserver/etcdserverpb",
+			"revision": "fff1fb2ed7510d569498cad3161f3ec938a0f4d4",
+			"revisionTime": "2017-10-25T00:38:12Z"
+		},
+		{
+			"checksumSHA1": "JAkX9DfIBrSe0vUa07xl5cikxVQ=",
+			"path": "github.com/coreos/etcd/mvcc/mvccpb",
+			"revision": "fff1fb2ed7510d569498cad3161f3ec938a0f4d4",
+			"revisionTime": "2017-10-25T00:38:12Z"
+		},
 		{
 			"checksumSHA1": "mKIXx1kDwmVmdIpZ3pJtRBuUKso=",
 			"comment": "v2.3.0-alpha.0-652-ge552791",
 			"path": "github.com/coreos/etcd/pkg/pathutil",
 			"revision": "e5527914aa42cae3063f52892e1ca4518da0e4ae"
 		},
+		{
+			"checksumSHA1": "rMyIh9PsSvPs6Yd+YgKITQzQJx8=",
+			"path": "github.com/coreos/etcd/pkg/tlsutil",
+			"revision": "fff1fb2ed7510d569498cad3161f3ec938a0f4d4",
+			"revisionTime": "2017-10-25T00:38:12Z"
+		},
+		{
+			"checksumSHA1": "agofzi+YZ7VYbxCldLaHYHAtlpc=",
+			"path": "github.com/coreos/etcd/pkg/transport",
+			"revision": "fff1fb2ed7510d569498cad3161f3ec938a0f4d4",
+			"revisionTime": "2017-10-25T00:38:12Z"
+		},
 		{
 			"checksumSHA1": "dMR9ipwCbX5eIPnvLXiPUM65/0s=",
 			"comment": "v2.3.0-alpha.0-652-ge552791",
@@ -848,6 +908,30 @@
 			"revision": "8ee79997227bf9b34611aee7946ae64735e6fd93",
 			"revisionTime": "2016-11-17T03:31:26Z"
 		},
+		{
+			"checksumSHA1": "VfkiItDBFFkZluaAMAzJipDXNBY=",
+			"path": "github.com/golang/protobuf/ptypes",
+			"revision": "1643683e1b54a9e88ad26d98f81400c8c9d9f4f9",
+			"revisionTime": "2017-10-21T04:39:52Z"
+		},
+		{
+			"checksumSHA1": "UB9scpDxeFjQe5tEthuR4zCLRu4=",
+			"path": "github.com/golang/protobuf/ptypes/any",
+			"revision": "1643683e1b54a9e88ad26d98f81400c8c9d9f4f9",
+			"revisionTime": "2017-10-21T04:39:52Z"
+		},
+		{
+			"checksumSHA1": "hUjAj0dheFVDl84BAnSWj9qy2iY=",
+			"path": "github.com/golang/protobuf/ptypes/duration",
+			"revision": "1643683e1b54a9e88ad26d98f81400c8c9d9f4f9",
+			"revisionTime": "2017-10-21T04:39:52Z"
+		},
+		{
+			"checksumSHA1": "O2ItP5rmfrgxPufhjJXbFlXuyL8=",
+			"path": "github.com/golang/protobuf/ptypes/timestamp",
+			"revision": "1643683e1b54a9e88ad26d98f81400c8c9d9f4f9",
+			"revisionTime": "2017-10-21T04:39:52Z"
+		},
 		{
 			"checksumSHA1": "V/53BpqgOkSDZCX6snQCAkdO2fM=",
 			"path": "github.com/googleapis/gax-go",
@@ -1190,6 +1274,12 @@
 			"revision": "c3d66e76678dce180a7b452653472f949aedfbcd",
 			"revisionTime": "2017-02-07T21:55:32Z"
 		},
+		{
+			"checksumSHA1": "AA0aYmdg4pb5gPCUSXg8iPzxLag=",
+			"path": "github.com/hashicorp/go-hclog",
+			"revision": "ca137eb4b4389c9bc6f1a6d887f056bf16c00510",
+			"revisionTime": "2017-10-05T15:17:51Z"
+		},
 		{
 			"checksumSHA1": "lrSl49G23l6NhfilxPM0XFs5rZo=",
 			"path": "github.com/hashicorp/go-multierror",
@@ -1278,6 +1368,42 @@
 			"revision": "a4b07c25de5ff55ad3b8936cea69a79a3d95a855",
 			"revisionTime": "2017-05-04T19:02:34Z"
 		},
+		{
+			"checksumSHA1": "6kxMiZSmgazD/CZgmnEeEMJSAOM=",
+			"path": "github.com/hashicorp/hcl2/gohcl",
+			"revision": "44bad6dbf5490f5da17ec991e664df3d017b706f",
+			"revisionTime": "2017-10-03T23:27:34Z"
+		},
+		{
+			"checksumSHA1": "TsNlThzf92FMwcnM4Fc0mArHroU=",
+			"path": "github.com/hashicorp/hcl2/hcl",
+			"revision": "44bad6dbf5490f5da17ec991e664df3d017b706f",
+			"revisionTime": "2017-10-03T23:27:34Z"
+		},
+		{
+			"checksumSHA1": "+Dv8V2cfl7Vy6rUklhXj5Cli8aU=",
+			"path": "github.com/hashicorp/hcl2/hcl/hclsyntax",
+			"revision": "44bad6dbf5490f5da17ec991e664df3d017b706f",
+			"revisionTime": "2017-10-03T23:27:34Z"
+		},
+		{
+			"checksumSHA1": "GAArMzjaoFNPa7HFnhjZmaeBZII=",
+			"path": "github.com/hashicorp/hcl2/hcl/json",
+			"revision": "44bad6dbf5490f5da17ec991e664df3d017b706f",
+			"revisionTime": "2017-10-03T23:27:34Z"
+		},
+		{
+			"checksumSHA1": "u6YPoPz3GflgHb1dN1YN8nCWAXY=",
+			"path": "github.com/hashicorp/hcl2/hcldec",
+			"revision": "44bad6dbf5490f5da17ec991e664df3d017b706f",
+			"revisionTime": "2017-10-03T23:27:34Z"
+		},
+		{
+			"checksumSHA1": "IzmftuG99BqNhbFGhxZaGwtiMtM=",
+			"path": "github.com/hashicorp/hcl2/hclparse",
+			"revision": "44bad6dbf5490f5da17ec991e664df3d017b706f",
+			"revisionTime": "2017-10-03T23:27:34Z"
+		},
 		{
 			"checksumSHA1": "M09yxoBoCEtG7EcHR8aEWLzMMJc=",
 			"path": "github.com/hashicorp/hil",
@@ -1362,6 +1488,12 @@
 			"version": "v0.10.0",
 			"versionExact": "v0.10.0"
 		},
+		{
+			"checksumSHA1": "sWPPRyIsfATpFxTqRc9PgbazRAc=",
+			"path": "github.com/hashicorp/terraform/backend/remote-state/azure",
+			"revision": "12b6ec9241401e2222c8acd095d74ac207b389ca",
+			"revisionTime": "2017-10-25T16:17:09Z"
+		},
 		{
 			"checksumSHA1": "ckRjYzdabaVIFIHfCo9/McYi3PI=",
 			"path": "github.com/hashicorp/terraform/backend/remote-state/consul",
@@ -1370,6 +1502,12 @@
 			"version": "v0.10.0",
 			"versionExact": "v0.10.0"
 		},
+		{
+			"checksumSHA1": "SllujprNPMotiPKfcPsQRF/7r64=",
+			"path": "github.com/hashicorp/terraform/backend/remote-state/etcdv3",
+			"revision": "12b6ec9241401e2222c8acd095d74ac207b389ca",
+			"revisionTime": "2017-10-25T16:17:09Z"
+		},
 		{
 			"checksumSHA1": "2DlWhwNky9LZSRAy0LmSdPHhF2s=",
 			"path": "github.com/hashicorp/terraform/backend/remote-state/inmem",
@@ -1418,6 +1556,18 @@
 			"version": "v0.10.0",
 			"versionExact": "v0.10.0"
 		},
+		{
+			"checksumSHA1": "qzvSGXa0rLkhSSha9fZQkfk6UG4=",
+			"path": "github.com/hashicorp/terraform/config/configschema",
+			"revision": "12b6ec9241401e2222c8acd095d74ac207b389ca",
+			"revisionTime": "2017-10-25T16:17:09Z"
+		},
+		{
+			"checksumSHA1": "3V7300kyZF+AGy/cOKV0+P6M3LY=",
+			"path": "github.com/hashicorp/terraform/config/hcl2shim",
+			"revision": "12b6ec9241401e2222c8acd095d74ac207b389ca",
+			"revisionTime": "2017-10-25T16:17:09Z"
+		},
 		{
 			"checksumSHA1": "uPCJ6seQo9kvoNSfwNWKX9KzVMk=",
 			"path": "github.com/hashicorp/terraform/config/module",
@@ -1557,8 +1707,8 @@
 		{
 			"checksumSHA1": "yFWmdS6yEJZpRJzUqd/mULqCYGk=",
 			"path": "github.com/hashicorp/terraform/moduledeps",
-			"revision": "5bcc1bae5925f44208a83279b6d4d250da01597b",
-			"revisionTime": "2017-08-09T21:54:59Z"
+			"revision": "12b6ec9241401e2222c8acd095d74ac207b389ca",
+			"revisionTime": "2017-10-25T16:17:09Z"
 		},
 		{
 			"checksumSHA1": "4ODNVUds3lyBf7gV02X1EeYR4GA=",
@@ -1600,6 +1750,18 @@
 			"version": "v0.10.0",
 			"versionExact": "v0.10.0"
 		},
+		{
+			"checksumSHA1": "C3c1+sTF/97mT6N+15bVSq4Ryr8=",
+			"path": "github.com/hashicorp/terraform/tfdiags",
+			"revision": "12b6ec9241401e2222c8acd095d74ac207b389ca",
+			"revisionTime": "2017-10-25T16:17:09Z"
+		},
+		{
+			"checksumSHA1": "HY66V8hbkC5EvjI/Faix9gYQfq8=",
+			"path": "github.com/hashicorp/terraform/version",
+			"revision": "12b6ec9241401e2222c8acd095d74ac207b389ca",
+			"revisionTime": "2017-10-25T16:17:09Z"
+		},
 		{
 			"checksumSHA1": "ft77GtqeZEeCXioGpF/s6DlGm/U=",
 			"path": "github.com/hashicorp/vault/helper/compressutil",
@@ -1770,6 +1932,12 @@
 			"revision": "b8bc1bf767474819792c23f32d8286a45736f1c6",
 			"revisionTime": "2016-12-03T19:45:07Z"
 		},
+		{
+			"checksumSHA1": "L3leymg2RT8hFl5uL+5KP/LpBkg=",
+			"path": "github.com/mitchellh/go-wordwrap",
+			"revision": "ad45545899c7b13c020ea92b2072220eefad42b8",
+			"revisionTime": "2015-03-14T17:03:34Z"
+		},
 		{
 			"checksumSHA1": "xyoJKalfQwTUN1qzZGQKWYAwl0A=",
 			"path": "github.com/mitchellh/hashstructure",
@@ -1819,6 +1987,48 @@
 			"revision": "c27870419a71395bc45252c27024a306f9cd71f7",
 			"revisionTime": "2017-08-09T20:42:51Z"
 		},
+		{
+			"checksumSHA1": "R9ayYqxeUsPcIbs6KXCVwDIdf6M=",
+			"path": "github.com/zclconf/go-cty/cty",
+			"revision": "8bf222d6d03b7b336d013978f3acbfd877da428f",
+			"revisionTime": "2017-10-13T21:58:09Z"
+		},
+		{
+			"checksumSHA1": "IjvfMUZ9S1L1NM0haXwMfKzkyvM=",
+			"path": "github.com/zclconf/go-cty/cty/convert",
+			"revision": "8bf222d6d03b7b336d013978f3acbfd877da428f",
+			"revisionTime": "2017-10-13T21:58:09Z"
+		},
+		{
+			"checksumSHA1": "TU21yqpRZdbEbH8pp4I5YsQa00E=",
+			"path": "github.com/zclconf/go-cty/cty/function",
+			"revision": "8bf222d6d03b7b336d013978f3acbfd877da428f",
+			"revisionTime": "2017-10-13T21:58:09Z"
+		},
+		{
+			"checksumSHA1": "Ke4kpRBTSophcLSCrusR8XxSC0Y=",
+			"path": "github.com/zclconf/go-cty/cty/function/stdlib",
+			"revision": "8bf222d6d03b7b336d013978f3acbfd877da428f",
+			"revisionTime": "2017-10-13T21:58:09Z"
+		},
+		{
+			"checksumSHA1": "tmCzwfNXOEB1sSO7TKVzilb2vjA=",
+			"path": "github.com/zclconf/go-cty/cty/gocty",
+			"revision": "8bf222d6d03b7b336d013978f3acbfd877da428f",
+			"revisionTime": "2017-10-13T21:58:09Z"
+		},
+		{
+			"checksumSHA1": "1ApmO+Q33+Oem/3f6BU6sztJWNc=",
+			"path": "github.com/zclconf/go-cty/cty/json",
+			"revision": "8bf222d6d03b7b336d013978f3acbfd877da428f",
+			"revisionTime": "2017-10-13T21:58:09Z"
+		},
+		{
+			"checksumSHA1": "gH4rRyzIQknMIXAJfpvC04KTsME=",
+			"path": "github.com/zclconf/go-cty/cty/set",
+			"revision": "8bf222d6d03b7b336d013978f3acbfd877da428f",
+			"revisionTime": "2017-10-13T21:58:09Z"
+		},
 		{
 			"checksumSHA1": "vE43s37+4CJ2CDU6TlOUOYE0K9c=",
 			"path": "golang.org/x/crypto/bcrypt",
@@ -1968,6 +2178,18 @@
 			"revision": "d75a52659825e75fff6158388dddc6a5b04f9ba5",
 			"revisionTime": "2016-12-14T18:38:57Z"
 		},
+		{
+			"checksumSHA1": "ziMb9+ANGRJSSIuxYdRbA+cDRBQ=",
+			"path": "golang.org/x/text/transform",
+			"revision": "6eab0e8f74e86c598ec3b6fad4888e0c11482d48",
+			"revisionTime": "2017-09-27T13:34:20Z"
+		},
+		{
+			"checksumSHA1": "km/8bLtOpIP7sua4MnEmiSDYTAE=",
+			"path": "golang.org/x/text/unicode/norm",
+			"revision": "6eab0e8f74e86c598ec3b6fad4888e0c11482d48",
+			"revisionTime": "2017-09-27T13:34:20Z"
+		},
 		{
 			"checksumSHA1": "C7k1pbU/WU4CBoBwA4EBUnV/iek=",
 			"path": "google.golang.org/api/gensupport",
@@ -2032,6 +2254,12 @@
 			"path": "google.golang.org/appengine/internal/remote_api",
 			"revision": "b667a5000b082e49c6c6d16867d376a12e9490cd"
 		},
+		{
+			"checksumSHA1": "Tc3BU26zThLzcyqbVtiSEp7EpU8=",
+			"path": "google.golang.org/genproto/googleapis/rpc/status",
+			"revision": "f676e0f3ac6395ff1a529ae59a6670878a8371a6",
+			"revisionTime": "2017-10-02T23:26:14Z"
+		},
 		{
 			"checksumSHA1": "epHwh7hDQSYzDowPIbw8vnLzPS0=",
 			"path": "google.golang.org/grpc",
@@ -2056,12 +2284,24 @@
 			"revision": "50955793b0183f9de69bd78e2ec251cf20aab121",
 			"revisionTime": "2017-01-11T19:10:52Z"
 		},
+		{
+			"checksumSHA1": "6vY7tYjV84pnr3sDctzx53Bs8b0=",
+			"path": "google.golang.org/grpc/health/grpc_health_v1",
+			"revision": "c5f391bd6cc812a308d2aaa285995ce0b9bb4452",
+			"revisionTime": "2017-10-25T17:31:00Z"
+		},
 		{
 			"checksumSHA1": "T3Q0p8kzvXFnRkMaK/G8mCv6mc0=",
 			"path": "google.golang.org/grpc/internal",
 			"revision": "50955793b0183f9de69bd78e2ec251cf20aab121",
 			"revisionTime": "2017-01-11T19:10:52Z"
 		},
+		{
+			"checksumSHA1": "hcuHgKp8W0wIzoCnNfKI8NUss5o=",
+			"path": "google.golang.org/grpc/keepalive",
+			"revision": "c5f391bd6cc812a308d2aaa285995ce0b9bb4452",
+			"revisionTime": "2017-10-25T17:31:00Z"
+		},
 		{
 			"checksumSHA1": "XXpD8+S3gLrfmCLOf+RbxblOQkU=",
 			"path": "google.golang.org/grpc/metadata",
@@ -2086,6 +2326,12 @@
 			"revision": "50955793b0183f9de69bd78e2ec251cf20aab121",
 			"revisionTime": "2017-01-11T19:10:52Z"
 		},
+		{
+			"checksumSHA1": "3Dwz4RLstDHMPyDA7BUsYe+JP4w=",
+			"path": "google.golang.org/grpc/status",
+			"revision": "c5f391bd6cc812a308d2aaa285995ce0b9bb4452",
+			"revisionTime": "2017-10-25T17:31:00Z"
+		},
 		{
 			"checksumSHA1": "N0TftT6/CyWqp6VRi2DqDx60+Fo=",
 			"path": "google.golang.org/grpc/tap",