From 3654dcef9aaf737a7f628c4033e607d6687e8537 Mon Sep 17 00:00:00 2001
From: "dependabot[bot]" <49699333+dependabot[bot]@users.noreply.github.com>
Date: Wed, 8 Apr 2026 00:05:15 +0000
Subject: [PATCH] Bump github.com/samber/lo from 1.31.0 to 1.53.0

Bumps [github.com/samber/lo](https://github.com/samber/lo) from 1.31.0 to 1.53.0.
- [Release notes](https://github.com/samber/lo/releases)
- [Commits](https://github.com/samber/lo/compare/v1.31.0...v1.53.0)

---
updated-dependencies:
- dependency-name: github.com/samber/lo
  dependency-version: 1.53.0
  dependency-type: direct:production
  update-type: version-update:semver-minor
...

Signed-off-by: dependabot[bot] <support@github.com>
---
 go.mod                                        |    2 +-
 go.sum                                        |    6 +-
 vendor/github.com/samber/lo/.golangci.yml     |  104 +
 vendor/github.com/samber/lo/.travis.yml       |    7 -
 vendor/github.com/samber/lo/CHANGELOG.md      |  347 --
 vendor/github.com/samber/lo/Dockerfile        |    2 +-
 vendor/github.com/samber/lo/LICENSE           |    2 +-
 vendor/github.com/samber/lo/Makefile          |   57 +-
 vendor/github.com/samber/lo/README.md         | 3244 +++++++++++++--
 vendor/github.com/samber/lo/channel.go        |  162 +-
 vendor/github.com/samber/lo/concurrency.go    |   92 +-
 vendor/github.com/samber/lo/condition.go      |   27 +-
 .../github.com/samber/lo/docker-compose.yml   |    9 -
 vendor/github.com/samber/lo/errors.go         |  132 +-
 vendor/github.com/samber/lo/find.go           |  889 ++++-
 vendor/github.com/samber/lo/func.go           |   41 +-
 .../samber/lo/internal/constraints/README.md  |    4 +
 .../lo/internal/constraints/constraints.go    |   42 +
 .../lo/internal/constraints/ordered_go118.go  |   11 +
 .../lo/internal/constraints/ordered_go121.go  |   13 +
 .../samber/lo/internal/xrand/ordered_go118.go |   32 +
 .../samber/lo/internal/xrand/ordered_go122.go |   23 +
 .../samber/lo/internal/xtime/README.md        |    6 +
 .../samber/lo/internal/xtime/fake.go          |   40 +
 .../samber/lo/internal/xtime/noCopy.go        |   14 +
 .../samber/lo/internal/xtime/real.go          |   30 +
 .../samber/lo/internal/xtime/time.go          |   33 +
 vendor/github.com/samber/lo/intersect.go      |  335 +-
 vendor/github.com/samber/lo/map.go            |  435 +-
 vendor/github.com/samber/lo/math.go           |  183 +-
 vendor/github.com/samber/lo/mutable/slice.go  |   73 +
 vendor/github.com/samber/lo/retry.go          |  316 +-
 vendor/github.com/samber/lo/slice.go          | 1097 +++++-
 vendor/github.com/samber/lo/string.go         |  295 +-
 vendor/github.com/samber/lo/test.go           |   32 -
 vendor/github.com/samber/lo/time.go           |   99 +
 vendor/github.com/samber/lo/tuples.go         | 1806 +++++++--
 .../github.com/samber/lo/type_manipulation.go |  178 +-
 vendor/github.com/samber/lo/types.go          |   64 +-
 vendor/golang.org/x/text/cases/cases.go       |  162 +
 vendor/golang.org/x/text/cases/context.go     |  376 ++
 vendor/golang.org/x/text/cases/fold.go        |   34 +
 vendor/golang.org/x/text/cases/icu.go         |   61 +
 vendor/golang.org/x/text/cases/info.go        |   82 +
 vendor/golang.org/x/text/cases/map.go         |  816 ++++
 .../golang.org/x/text/cases/tables15.0.0.go   | 2527 ++++++++++++
 .../golang.org/x/text/cases/tables17.0.0.go   | 2642 +++++++++++++
 vendor/golang.org/x/text/cases/trieval.go     |  217 +
 vendor/golang.org/x/text/internal/internal.go |   49 +
 .../x/text/internal/language/common.go        |   16 +
 .../x/text/internal/language/compact.go       |   29 +
 .../text/internal/language/compact/compact.go |   61 +
 .../internal/language/compact/language.go     |  260 ++
 .../text/internal/language/compact/parents.go |  120 +
 .../text/internal/language/compact/tables.go  | 1015 +++++
 .../x/text/internal/language/compact/tags.go  |   91 +
 .../x/text/internal/language/compose.go       |  167 +
 .../x/text/internal/language/coverage.go      |   28 +
 .../x/text/internal/language/language.go      |  627 +++
 .../x/text/internal/language/lookup.go        |  412 ++
 .../x/text/internal/language/match.go         |  226 ++
 .../x/text/internal/language/parse.go         |  608 +++
 .../x/text/internal/language/tables.go        | 3494 +++++++++++++++++
 .../x/text/internal/language/tags.go          |   48 +
 vendor/golang.org/x/text/internal/match.go    |   67 +
 vendor/golang.org/x/text/internal/tag/tag.go  |  100 +
 vendor/golang.org/x/text/language/coverage.go |  187 +
 vendor/golang.org/x/text/language/doc.go      |   98 +
 vendor/golang.org/x/text/language/language.go |  605 +++
 vendor/golang.org/x/text/language/match.go    |  735 ++++
 vendor/golang.org/x/text/language/parse.go    |  256 ++
 vendor/golang.org/x/text/language/tables.go   |  298 ++
 vendor/golang.org/x/text/language/tags.go     |  145 +
 vendor/modules.txt                            |   12 +-
 74 files changed, 25274 insertions(+), 1681 deletions(-)
 create mode 100644 vendor/github.com/samber/lo/.golangci.yml
 delete mode 100644 vendor/github.com/samber/lo/.travis.yml
 delete mode 100644 vendor/github.com/samber/lo/CHANGELOG.md
 delete mode 100644 vendor/github.com/samber/lo/docker-compose.yml
 create mode 100644 vendor/github.com/samber/lo/internal/constraints/README.md
 create mode 100644 vendor/github.com/samber/lo/internal/constraints/constraints.go
 create mode 100644 vendor/github.com/samber/lo/internal/constraints/ordered_go118.go
 create mode 100644 vendor/github.com/samber/lo/internal/constraints/ordered_go121.go
 create mode 100644 vendor/github.com/samber/lo/internal/xrand/ordered_go118.go
 create mode 100644 vendor/github.com/samber/lo/internal/xrand/ordered_go122.go
 create mode 100644 vendor/github.com/samber/lo/internal/xtime/README.md
 create mode 100644 vendor/github.com/samber/lo/internal/xtime/fake.go
 create mode 100644 vendor/github.com/samber/lo/internal/xtime/noCopy.go
 create mode 100644 vendor/github.com/samber/lo/internal/xtime/real.go
 create mode 100644 vendor/github.com/samber/lo/internal/xtime/time.go
 create mode 100644 vendor/github.com/samber/lo/mutable/slice.go
 delete mode 100644 vendor/github.com/samber/lo/test.go
 create mode 100644 vendor/github.com/samber/lo/time.go
 create mode 100644 vendor/golang.org/x/text/cases/cases.go
 create mode 100644 vendor/golang.org/x/text/cases/context.go
 create mode 100644 vendor/golang.org/x/text/cases/fold.go
 create mode 100644 vendor/golang.org/x/text/cases/icu.go
 create mode 100644 vendor/golang.org/x/text/cases/info.go
 create mode 100644 vendor/golang.org/x/text/cases/map.go
 create mode 100644 vendor/golang.org/x/text/cases/tables15.0.0.go
 create mode 100644 vendor/golang.org/x/text/cases/tables17.0.0.go
 create mode 100644 vendor/golang.org/x/text/cases/trieval.go
 create mode 100644 vendor/golang.org/x/text/internal/internal.go
 create mode 100644 vendor/golang.org/x/text/internal/language/common.go
 create mode 100644 vendor/golang.org/x/text/internal/language/compact.go
 create mode 100644 vendor/golang.org/x/text/internal/language/compact/compact.go
 create mode 100644 vendor/golang.org/x/text/internal/language/compact/language.go
 create mode 100644 vendor/golang.org/x/text/internal/language/compact/parents.go
 create mode 100644 vendor/golang.org/x/text/internal/language/compact/tables.go
 create mode 100644 vendor/golang.org/x/text/internal/language/compact/tags.go
 create mode 100644 vendor/golang.org/x/text/internal/language/compose.go
 create mode 100644 vendor/golang.org/x/text/internal/language/coverage.go
 create mode 100644 vendor/golang.org/x/text/internal/language/language.go
 create mode 100644 vendor/golang.org/x/text/internal/language/lookup.go
 create mode 100644 vendor/golang.org/x/text/internal/language/match.go
 create mode 100644 vendor/golang.org/x/text/internal/language/parse.go
 create mode 100644 vendor/golang.org/x/text/internal/language/tables.go
 create mode 100644 vendor/golang.org/x/text/internal/language/tags.go
 create mode 100644 vendor/golang.org/x/text/internal/match.go
 create mode 100644 vendor/golang.org/x/text/internal/tag/tag.go
 create mode 100644 vendor/golang.org/x/text/language/coverage.go
 create mode 100644 vendor/golang.org/x/text/language/doc.go
 create mode 100644 vendor/golang.org/x/text/language/language.go
 create mode 100644 vendor/golang.org/x/text/language/match.go
 create mode 100644 vendor/golang.org/x/text/language/parse.go
 create mode 100644 vendor/golang.org/x/text/language/tables.go
 create mode 100644 vendor/golang.org/x/text/language/tags.go

diff --git a/go.mod b/go.mod
index fb8989e71a7..803474669f3 100644
--- a/go.mod
+++ b/go.mod
@@ -28,7 +28,7 @@ require (
 	github.com/mitchellh/go-ps v1.0.0
 	github.com/rivo/uniseg v0.4.7
 	github.com/sahilm/fuzzy v0.1.1
-	github.com/samber/lo v1.31.0
+	github.com/samber/lo v1.53.0
 	github.com/sanity-io/litter v1.5.8
 	github.com/sasha-s/go-deadlock v0.3.9
 	github.com/sirupsen/logrus v1.9.3
diff --git a/go.sum b/go.sum
index f6af7546121..4fa41eeeb44 100644
--- a/go.sum
+++ b/go.sum
@@ -105,8 +105,8 @@ github.com/rogpeppe/go-internal v1.14.1 h1:UQB4HGPB6osV0SQTLymcB4TgvyWu6ZyliaW0t
 github.com/rogpeppe/go-internal v1.14.1/go.mod h1:MaRKkUm5W0goXpeCfT7UZI6fk/L7L7so1lCWt35ZSgc=
 github.com/sahilm/fuzzy v0.1.1 h1:ceu5RHF8DGgoi+/dR5PsECjCDH1BE3Fnmpo7aVXOdRA=
 github.com/sahilm/fuzzy v0.1.1/go.mod h1:VFvziUEIMCrT6A6tw2RFIXPXXmzXbOsSHF0DOI8ZK9Y=
-github.com/samber/lo v1.31.0 h1:Sfa+/064Tdo4SvlohQUQzBhgSer9v/coGvKQI/XLWAM=
-github.com/samber/lo v1.31.0/go.mod h1:HLeWcJRRyLKp3+/XBJvOrerCQn9mhdKMHyd7IRlgeQ8=
+github.com/samber/lo v1.53.0 h1:t975lj2py4kJPQ6haz1QMgtId2gtmfktACxIXArw3HM=
+github.com/samber/lo v1.53.0/go.mod h1:4+MXEGsJzbKGaUEQFKBq2xtfuznW9oz/WrgyzMzRoM0=
 github.com/sanity-io/litter v1.5.8 h1:uM/2lKrWdGbRXDrIq08Lh9XtVYoeGtcQxk9rtQ7+rYg=
 github.com/sanity-io/litter v1.5.8/go.mod h1:9gzJgR2i4ZpjZHsKvUXIRQVk7P+yM3e+jAF7bU2UI5U=
 github.com/sasha-s/go-deadlock v0.3.9 h1:fiaT9rB7g5sr5ddNZvlwheclN9IP86eFW9WgqlEQV+w=
@@ -125,8 +125,6 @@ github.com/stretchr/testify v1.6.1/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/
 github.com/stretchr/testify v1.7.0/go.mod h1:6Fq8oRcR53rry900zMqJjRRixrwX3KX962/h/Wwjteg=
 github.com/stretchr/testify v1.11.1 h1:7s2iGBzp5EwR7/aIZr8ao5+dra3wiQyKjjFuvgVKu7U=
 github.com/stretchr/testify v1.11.1/go.mod h1:wZwfW3scLgRK+23gO65QZefKpKQRnfz6sD981Nm4B6U=
-github.com/thoas/go-funk v0.9.1 h1:O549iLZqPpTUQ10ykd26sZhzD+rmR5pWhuElrhbC20M=
-github.com/thoas/go-funk v0.9.1/go.mod h1:+IWnUfUmFO1+WVYQWQtIJHeRRdaIyyYglZN7xzUPe4Q=
 github.com/urfave/cli v1.20.1-0.20180226030253-8e01ec4cd3e2/go.mod h1:70zkFmudgCuE/ngEzBv17Jvp/497gISqfk5gWijbERA=
 github.com/wk8/go-ordered-map/v2 v2.1.8 h1:5h/BUHu93oj4gIdvHHHGsScSTMijfx5PeYkE/fJgbpc=
 github.com/wk8/go-ordered-map/v2 v2.1.8/go.mod h1:5nJHM5DyteebpVlHnWMV0rPz6Zp7+xBAnxjb1X5vnTw=
diff --git a/vendor/github.com/samber/lo/.golangci.yml b/vendor/github.com/samber/lo/.golangci.yml
new file mode 100644
index 00000000000..2f6c810ff39
--- /dev/null
+++ b/vendor/github.com/samber/lo/.golangci.yml
@@ -0,0 +1,104 @@
+version: "2"
+run:
+  concurrency: 4
+  # also lint _test.go files
+  tests: true
+  timeout: 5m
+linters:
+  enable:
+    - govet
+    - staticcheck
+    - unused
+    - errcheck
+    - gocritic
+    - gocyclo
+    - revive
+    - ineffassign
+    - unconvert
+    - goconst
+    # - depguard
+    - prealloc
+    # - dupl
+    - misspell
+    - bodyclose
+    - sqlclosecheck
+    - nilerr
+    - nestif
+    - forcetypeassert
+    - exhaustive
+    - funlen
+    # - wsl_v5
+    - testifylint
+    - whitespace
+    - perfsprint
+    - nolintlint
+    - godot
+    - thelper
+    - tparallel
+    - paralleltest
+    - predeclared
+
+  # disable noisy/controversial ones which you might enable later
+  disable:
+    - lll          # line length — handled by gofmt/gofumpt
+
+  settings:
+    dupl:
+      threshold: 20  # lower => stricter (tokens)
+    errcheck:
+      check-type-assertions: true
+    funlen:
+      lines: 120
+      statements: 80
+    goconst:
+      min-len: 2
+      min-occurrences: 3
+    gocyclo:
+      min-complexity: 15 # strict; lower => stricter
+    wsl_v5:
+      allow-first-in-block: true
+      allow-whole-block: false
+      branch-max-lines: 2
+    testifylint:
+      disable:
+        - require-error
+        - float-compare
+
+  exclusions:
+    generated: lax
+    paths:
+      - examples$
+    rules:
+      - linters:
+          - revive
+        text: "^unused-parameter:"
+      - linters:
+          - revive
+        text: "^package-comments:"
+      - linters:
+          - errcheck
+        text: "Error return value of `.*\\.Body\\.Close` is not checked"
+      # linters disabled in tests
+      - linters:
+          - dupl
+          - goconst
+          - funlen
+        path: "_test\\.go$"
+
+issues:
+  max-issues-per-linter: 0  # 0 = unlimited (we want ALL issues)
+  max-same-issues: 100
+
+formatters:
+  enable:
+    - gofmt
+    - gofumpt
+  settings:
+    gofumpt:
+      extra-rules: true
+  exclusions:
+    generated: lax
+    paths:
+      - third_party$
+      - builtin$
+      - examples$
diff --git a/vendor/github.com/samber/lo/.travis.yml b/vendor/github.com/samber/lo/.travis.yml
deleted file mode 100644
index f0de7f51c46..00000000000
--- a/vendor/github.com/samber/lo/.travis.yml
+++ /dev/null
@@ -1,7 +0,0 @@
-language: go
-before_install:
-  - go mod download
-  - make tools
-go:
-  - "1.18"
-script: make test
diff --git a/vendor/github.com/samber/lo/CHANGELOG.md b/vendor/github.com/samber/lo/CHANGELOG.md
deleted file mode 100644
index 9ba32f1b6c4..00000000000
--- a/vendor/github.com/samber/lo/CHANGELOG.md
+++ /dev/null
@@ -1,347 +0,0 @@
-# Changelog
-
-@samber: I sometimes forget to update this file. Ping me on [Twitter](https://twitter.com/samuelberthe) or open an issue in case of error. We need to keep a clear changelog for easier lib upgrade.
-
-## 1.31.0 (2022-10-06)
-
-Adding:
-
-- lo.SliceToChannel
-- lo.Generator
-- lo.Batch
-- lo.BatchWithTimeout
-
-## 1.30.1 (2022-10-06)
-
-Fix:
-
-- lo.Try1: remove generic type
-- lo.Validate: format error properly
-
-## 1.30.0 (2022-10-04)
-
-Adding:
-
-- lo.TernaryF
-- lo.Validate
-
-## 1.29.0 (2022-10-02)
-
-Adding:
-
-- lo.ErrorAs
-- lo.TryOr
-- lo.TryOrX
-
-## 1.28.0 (2022-09-05)
-
-Adding:
-
-- lo.ChannelDispatcher with 6 dispatching strategies:
-  - lo.DispatchingStrategyRoundRobin
-  - lo.DispatchingStrategyRandom
-  - lo.DispatchingStrategyWeightedRandom
-  - lo.DispatchingStrategyFirst
-  - lo.DispatchingStrategyLeast
-  - lo.DispatchingStrategyMost
-
-## 1.27.1 (2022-08-15)
-
-Bugfix:
-
-- Removed comparable constraint for lo.FindKeyBy
-
-## 1.27.0 (2022-07-29)
-
-Breaking:
-
-- Change of MapToSlice prototype: `MapToSlice[K comparable, V any, R any](in map[K]V, iteratee func(V, K) R) []R` -> `MapToSlice[K comparable, V any, R any](in map[K]V, iteratee func(K, V) R) []R`
-
-Added:
-
-- lo.ChunkString
-- lo.SliceToMap (alias to lo.Associate)
-
-## 1.26.0 (2022-07-24)
-
-Adding:
-
-- lo.Associate
-- lo.ReduceRight
-- lo.FromPtrOr
-- lo.MapToSlice
-- lo.IsSorted
-- lo.IsSortedByKey
-
-## 1.25.0 (2022-07-04)
-
-Adding:
-
-- lo.FindUniques
-- lo.FindUniquesBy
-- lo.FindDuplicates
-- lo.FindDuplicatesBy
-- lo.IsNotEmpty
-
-## 1.24.0 (2022-07-04)
-
-Adding:
-
-- lo.Without
-- lo.WithoutEmpty
-
-## 1.23.0 (2022-07-04)
-
-Adding:
-
-- lo.FindKey
-- lo.FindKeyBy
-
-## 1.22.0 (2022-07-04)
-
-Adding:
-
-- lo.Slice
-- lo.FromPtr
-- lo.IsEmpty
-- lo.Compact
-- lo.ToPairs: alias to lo.Entries
-- lo.FromPairs: alias to lo.FromEntries
-- lo.Partial
-
-Change:
-
-- lo.Must + lo.MustX: add context to panic message
-
-Fix:
-
-- lo.Nth: out of bound exception (#137)
-
-## 1.21.0 (2022-05-10)
-
-Adding:
-
-- lo.ToAnySlice
-- lo.FromAnySlice
-
-## 1.20.0 (2022-05-02)
-
-Adding:
-
-- lo.Synchronize
-- lo.SumBy
-
-Change:
-- Removed generic type definition for lo.Try0: `lo.Try0[T]()` -> `lo.Try0()`
-
-## 1.19.0 (2022-04-30)
-
-Adding:
-
-- lo.RepeatBy
-- lo.Subset
-- lo.Replace
-- lo.ReplaceAll
-- lo.Substring
-- lo.RuneLength
-
-## 1.18.0 (2022-04-28)
-
-Adding:
-
-- lo.SomeBy
-- lo.EveryBy
-- lo.None
-- lo.NoneBy
-
-## 1.17.0 (2022-04-27)
-
-Adding:
-
-- lo.Unpack2 -> lo.Unpack3
-- lo.Async0 -> lo.Async6
-
-## 1.16.0 (2022-04-26)
-
-Adding:
-
-- lo.AttemptWithDelay
-
-## 1.15.0 (2022-04-22)
-
-Improvement:
-
-- lo.Must: error or boolean value
-
-## 1.14.0 (2022-04-21)
-
-Adding:
-
-- lo.Coalesce
-
-## 1.13.0 (2022-04-14)
-
-Adding:
-
-- PickBy
-- PickByKeys
-- PickByValues
-- OmitBy
-- OmitByKeys
-- OmitByValues
-- Clamp
-- MapKeys
-- Invert
-- IfF + ElseIfF + ElseF
-- T0() + T1() + T2() + T3() + ...
-
-## 1.12.0 (2022-04-12)
-
-Adding:
-
-- Must
-- Must{0-6}
-- FindOrElse
-- Async
-- MinBy
-- MaxBy
-- Count
-- CountBy
-- FindIndexOf
-- FindLastIndexOf
-- FilterMap
-
-## 1.11.0 (2022-03-11)
-
-Adding:
-
-- Try
-- Try{0-6}
-- TryWitchValue
-- TryCatch
-- TryCatchWitchValue
-- Debounce
-- Reject
-
-## 1.10.0 (2022-03-11)
-
-Adding:
-
-- Range
-- RangeFrom
-- RangeWithSteps
-
-## 1.9.0 (2022-03-10)
-
-Added
-
-- Drop
-- DropRight
-- DropWhile
-- DropRightWhile
-
-## 1.8.0 (2022-03-10)
-
-Adding Union.
-
-## 1.7.0 (2022-03-09)
-
-Adding ContainBy
-
-Adding MapValues
-
-Adding FlatMap
-
-## 1.6.0 (2022-03-07)
-
-Fixed PartitionBy.
-
-Adding Sample
-
-Adding Samples
-
-## 1.5.0 (2022-03-07)
-
-Adding Times
-
-Adding Attempt
-
-Adding Repeat
-
-## 1.4.0 (2022-03-07)
-
-- adding tuple types (2->9)
-- adding Zip + Unzip
-- adding lo.PartitionBy + lop.PartitionBy
-- adding lop.GroupBy
-- fixing Nth
-
-## 1.3.0 (2022-03-03)
-
-Last and Nth return errors
-
-## 1.2.0 (2022-03-03)
-
-Adding `lop.Map` and `lop.ForEach`.
-
-## 1.1.0 (2022-03-03)
-
-Adding `i int` param to `lo.Map()`, `lo.Filter()`, `lo.ForEach()` and `lo.Reduce()` predicates.
-
-## 1.0.0 (2022-03-02)
-
-*Initial release*
-
-Supported helpers for slices:
-
-- Filter
-- Map
-- Reduce
-- ForEach
-- Uniq
-- UniqBy
-- GroupBy
-- Chunk
-- Flatten
-- Shuffle
-- Reverse
-- Fill
-- ToMap
-
-Supported helpers for maps:
-
-- Keys
-- Values
-- Entries
-- FromEntries
-- Assign (maps merge)
-
-Supported intersection helpers:
-
-- Contains
-- Every
-- Some
-- Intersect
-- Difference
-
-Supported search helpers:
-
-- IndexOf
-- LastIndexOf
-- Find
-- Min
-- Max
-- Last
-- Nth
-
-Other functional programming helpers:
-
-- Ternary (1 line if/else statement)
-- If / ElseIf / Else
-- Switch / Case / Default
-- ToPtr
-- ToSlicePtr
-
-Constraints:
-
-- Clonable
diff --git a/vendor/github.com/samber/lo/Dockerfile b/vendor/github.com/samber/lo/Dockerfile
index bd01bbbb45b..5dbeb415bda 100644
--- a/vendor/github.com/samber/lo/Dockerfile
+++ b/vendor/github.com/samber/lo/Dockerfile
@@ -1,5 +1,5 @@
 
-FROM golang:1.18
+FROM golang:1.23.1
 
 WORKDIR /go/src/github.com/samber/lo
 
diff --git a/vendor/github.com/samber/lo/LICENSE b/vendor/github.com/samber/lo/LICENSE
index c3dc72d9ab8..2e3ebd5e83b 100644
--- a/vendor/github.com/samber/lo/LICENSE
+++ b/vendor/github.com/samber/lo/LICENSE
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2022 Samuel Berthe
+Copyright (c) 2022-2025 Samuel Berthe
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/vendor/github.com/samber/lo/Makefile b/vendor/github.com/samber/lo/Makefile
index 57bb49159f5..ad9267ba6b2 100644
--- a/vendor/github.com/samber/lo/Makefile
+++ b/vendor/github.com/samber/lo/Makefile
@@ -1,44 +1,57 @@
-
-BIN=go
+# Only build/test/lint exp/simd when Go version is >= 1.26 (requires goexperiment.simd)
+GO_VERSION := $(shell go version 2>/dev/null | sed -n 's/.*go\([0-9]*\)\.\([0-9]*\).*/\1.\2/p')
+GO_SIMD_SUPPORT := $(shell ver="$(GO_VERSION)"; [ -n "$$ver" ] && [ "$$(printf '%s\n1.26\n' "$$ver" | sort -V | tail -1)" = "$$ver" ] && echo yes)
 
 build:
-	${BIN} build -v ./...
+	go build -v ./...
+	@if [ -n "$(GO_SIMD_SUPPORT)" ]; then cd ./exp/simd && GOEXPERIMENT=simd go build -v ./; fi
 
 test:
-	go test -race -v ./...
+	go test -race ./...
+	@if [ -n "$(GO_SIMD_SUPPORT)" ]; then cd ./exp/simd && GOEXPERIMENT=simd go test -race ./; fi
 watch-test:
-	reflex -t 50ms -s -- sh -c 'gotest -race -v ./...'
+	reflex -t 50ms -s -- sh -c 'gotest -race ./...'
 
 bench:
-	go test -benchmem -count 3 -bench ./...
+	go test -v -run=^Benchmark -benchmem -count 3 -bench ./...
 watch-bench:
-	reflex -t 50ms -s -- sh -c 'go test -benchmem -count 3 -bench ./...'
+	reflex -t 50ms -s -- sh -c 'go test -v -run=^Benchmark -benchmem -count 3 -bench ./...'
 
 coverage:
-	${BIN} test -v -coverprofile=cover.out -covermode=atomic .
-	${BIN} tool cover -html=cover.out -o cover.html
+	go test -v -coverprofile=cover.out -covermode=atomic ./...
+	go tool cover -html=cover.out -o cover.html
 
-# tools
 tools:
-	${BIN} install github.com/cespare/reflex@latest
-	${BIN} install github.com/rakyll/gotest@latest
-	${BIN} install github.com/psampaz/go-mod-outdated@latest
-	${BIN} install github.com/jondot/goweight@latest
-	${BIN} install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
-	${BIN} get -t -u golang.org/x/tools/cmd/cover
-	${BIN} install github.com/sonatype-nexus-community/nancy@latest
+	go install github.com/cespare/reflex@latest
+	go install github.com/rakyll/gotest@latest
+	go install github.com/psampaz/go-mod-outdated@latest
+	go install github.com/jondot/goweight@latest
+	go install github.com/golangci/golangci-lint/cmd/golangci-lint@latest
+	go get -t -u golang.org/x/tools/cmd/cover
+	go install github.com/sonatype-nexus-community/nancy@latest
+	go install golang.org/x/perf/cmd/benchstat@latest
+	go install github.com/cespare/prettybench@latest
 	go mod tidy
 
+	# brew install hougesen/tap/mdsf
+
 lint:
 	golangci-lint run --timeout 60s --max-same-issues 50 ./...
+	@if [ -n "$(GO_SIMD_SUPPORT)" ]; then cd ./exp/simd && golangci-lint run --timeout 60s --max-same-issues 50 ./; fi
+	# mdsf verify --debug --log-level warn docs/
 lint-fix:
 	golangci-lint run --timeout 60s --max-same-issues 50 --fix ./...
+	@if [ -n "$(GO_SIMD_SUPPORT)" ]; then cd ./exp/simd && golangci-lint run --timeout 60s --max-same-issues 50 --fix ./; fi
+	# mdsf format --debug --log-level warn docs/
 
-audit: tools
-	${BIN} list -json -m all | nancy sleuth
+audit:
+	go list -json -m all | nancy sleuth
 
-outdated: tools
-	${BIN} list -u -m -json all | go-mod-outdated -update -direct
+outdated:
+	go list -u -m -json all | go-mod-outdated -update -direct
 
-weight: tools
+weight:
 	goweight
+
+doc:
+	cd docs && npm install && npm start
diff --git a/vendor/github.com/samber/lo/README.md b/vendor/github.com/samber/lo/README.md
index 49cbe49dab3..c9ad48344d9 100644
--- a/vendor/github.com/samber/lo/README.md
+++ b/vendor/github.com/samber/lo/README.md
@@ -1,27 +1,53 @@
-# lo
+
+# lo - Iterate over slices, maps, channels...
 
 [![tag](https://img.shields.io/github/tag/samber/lo.svg)](https://github.com/samber/lo/releases)
+![Go Version](https://img.shields.io/badge/Go-%3E%3D%201.18-%23007d9c)
 [![GoDoc](https://godoc.org/github.com/samber/lo?status.svg)](https://pkg.go.dev/github.com/samber/lo)
-![Build Status](https://github.com/samber/lo/actions/workflows/go.yml/badge.svg)
+![Build Status](https://github.com/samber/lo/actions/workflows/test.yml/badge.svg)
 [![Go report](https://goreportcard.com/badge/github.com/samber/lo)](https://goreportcard.com/report/github.com/samber/lo)
-[![codecov](https://codecov.io/gh/samber/lo/branch/master/graph/badge.svg)](https://codecov.io/gh/samber/lo)
+[![Coverage](https://img.shields.io/codecov/c/github/samber/lo)](https://codecov.io/gh/samber/lo)
+[![Contributors](https://img.shields.io/github/contributors/samber/lo)](https://github.com/samber/lo/graphs/contributors)
+[![License](https://img.shields.io/github/license/samber/lo)](./LICENSE)
 
 ✨ **`samber/lo` is a Lodash-style Go library based on Go 1.18+ Generics.**
 
-This project started as an experiment with the new generics implementation. It may look like [Lodash](https://github.com/lodash/lodash) in some aspects. I used to code with the fantastic ["go-funk"](https://github.com/thoas/go-funk) package, but "go-funk" uses reflection and therefore is not typesafe.
-
-As expected, benchmarks demonstrate that generics will be much faster than implementations based on the "reflect" package. Benchmarks also show similar performance gains compared to pure `for` loops. [See below](#-benchmark).
+A utility library based on Go 1.18+ generics that makes it easier to work with slices, maps, strings, channels, and functions. It provides dozens of handy methods to simplify common coding tasks and improve code readability. It may look like [Lodash](https://github.com/lodash/lodash) in some aspects.
 
-In the future, 5 to 10 helpers will overlap with those coming into the Go standard library (under package names `slices` and `maps`). I feel this library is legitimate and offers many more valuable abstractions.
+5 to 10 helpers may overlap with those from the Go standard library, in packages `slices` and `maps`. I feel this library is legitimate and offers many more valuable abstractions.
 
 **See also:**
 
+- [samber/ro](https://github.com/samber/ro): Reactive Programming for Go: declarative and composable API for event-driven applications
 - [samber/do](https://github.com/samber/do): A dependency injection toolkit based on Go 1.18+ Generics
 - [samber/mo](https://github.com/samber/mo): Monads based on Go 1.18+ Generics (Option, Result, Either...)
 
+What makes it different from **samber/ro**?
+- lo: synchronous helpers across finite sequences (maps, slices...)
+- ro: processing of infinite data streams for event-driven scenarios
+
+----
+
+<div align="center">
+  <sup><b>💖 Sponsored by:</b></sup>
+  <br>
+  <a href="https://www.dbos.dev/?utm_campaign=gh-smbr">
+    <div>
+	  <img width="200" alt="dbos" src="https://github.com/user-attachments/assets/d583cb62-7735-4d3c-beb7-e6ef1a5faf49" />
+    </div>
+    <div>
+      DBOS - Durable workflow orchestration library for Go
+    </div>
+  </a>
+</div>
+
+----
+
 **Why this name?**
 
-I wanted a **short name**, similar to "Lodash" and no Go package currently uses this name.
+I wanted a **short name**, similar to "Lodash", and no Go package uses this name.
+
+![lo](docs/static/img/logo-full.png)
 
 ## 🚀 Install
 
@@ -31,7 +57,9 @@ go get github.com/samber/lo@v1
 
 This library is v1 and follows SemVer strictly.
 
-No breaking changes will be made to exported APIs before v2.0.0.
+No breaking changes will be made to exported APIs before v2.0.0, except for experimental packages under `exp/`.
+
+This library has no dependencies outside the Go standard library.
 
 ## 💡 Usage
 
@@ -41,64 +69,109 @@ You can import `lo` using:
 import (
     "github.com/samber/lo"
     lop "github.com/samber/lo/parallel"
+    lom "github.com/samber/lo/mutable"
+    loi "github.com/samber/lo/it"
 )
 ```
 
 Then use one of the helpers below:
 
 ```go
-names := lo.Uniq[string]([]string{"Samuel", "Marc", "Samuel"})
-// []string{"Samuel", "Marc"}
+names := lo.Uniq([]string{"Samuel", "John", "Samuel"})
+// []string{"Samuel", "John"}
 ```
 
-Most of the time, the compiler will be able to infer the type so that you can call: `lo.Uniq([]string{...})`.
+### Tips for lazy developers
+
+I cannot recommend it, but in case you are too lazy for repeating `lo.` everywhere, you can import the entire library into the namespace.
+
+```go
+import (
+    . "github.com/samber/lo"
+)
+```
+
+I take no responsibility for this junk. 😁 💩
 
 ## 🤠 Spec
 
-GoDoc: [https://godoc.org/github.com/samber/lo](https://godoc.org/github.com/samber/lo)
+GoDoc: [godoc.org/github.com/samber/lo](https://godoc.org/github.com/samber/lo)
+
+Documentation: [lo.samber.dev](https://lo.samber.dev/docs/about)
 
 Supported helpers for slices:
 
 - [Filter](#filter)
 - [Map](#map)
+- [UniqMap](#uniqmap)
 - [FilterMap](#filtermap)
 - [FlatMap](#flatmap)
 - [Reduce](#reduce)
 - [ReduceRight](#reduceright)
 - [ForEach](#foreach)
+- [ForEachWhile](#foreachwhile)
 - [Times](#times)
 - [Uniq](#uniq)
 - [UniqBy](#uniqby)
 - [GroupBy](#groupby)
+- [GroupByMap](#groupbymap)
 - [Chunk](#chunk)
+- [Window](#window)
+- [Sliding](#sliding)
 - [PartitionBy](#partitionby)
 - [Flatten](#flatten)
+- [Concat](#concat)
+- [Interleave](#interleave)
 - [Shuffle](#shuffle)
 - [Reverse](#reverse)
 - [Fill](#fill)
 - [Repeat](#repeat)
 - [RepeatBy](#repeatby)
 - [KeyBy](#keyby)
-- [Associate / SliceToMap](#associate-alias-slicetomap)
+- [SliceToMap / Associate](#slicetomap-alias-associate)
+- [FilterSliceToMap](#filterslicetomap)
+- [Keyify](#keyify)
+- [Take](#take)
+- [TakeWhile](#takewhile)
+- [TakeFilter](#takefilter)
 - [Drop](#drop)
 - [DropRight](#dropright)
 - [DropWhile](#dropwhile)
 - [DropRightWhile](#droprightwhile)
+- [DropByIndex](#DropByIndex)
 - [Reject](#reject)
+- [RejectMap](#rejectmap)
+- [FilterReject](#filterreject)
 - [Count](#count)
 - [CountBy](#countby)
+- [CountValues](#countvalues)
+- [CountValuesBy](#countvaluesby)
 - [Subset](#subset)
 - [Slice](#slice)
 - [Replace](#replace)
 - [ReplaceAll](#replaceall)
+- [Clone](#clone)
 - [Compact](#compact)
 - [IsSorted](#issorted)
-- [IsSortedByKey](#issortedbykey)
+- [IsSortedBy](#issortedby)
+- [Splice](#Splice)
+- [Cut](#Cut)
+- [CutPrefix](#CutPrefix)
+- [CutSuffix](#CutSuffix)
+- [Trim](#Trim)
+- [TrimLeft](#TrimLeft)
+- [TrimPrefix](#TrimPrefix)
+- [TrimRight](#TrimRight)
+- [TrimSuffix](#TrimSuffix)
 
 Supported helpers for maps:
 
 - [Keys](#keys)
+- [UniqKeys](#uniqkeys)
+- [HasKey](#haskey)
+- [ValueOr](#valueor)
 - [Values](#values)
+- [UniqValues](#uniqvalues)
 - [PickBy](#pickby)
 - [PickByKeys](#pickbykeys)
 - [PickByValues](#pickbyvalues)
@@ -109,36 +182,68 @@ Supported helpers for maps:
 - [FromEntries / FromPairs](#fromentries-alias-frompairs)
 - [Invert](#invert)
 - [Assign (merge of maps)](#assign)
+- [ChunkEntries](#chunkentries)
 - [MapKeys](#mapkeys)
 - [MapValues](#mapvalues)
+- [MapEntries](#mapentries)
 - [MapToSlice](#maptoslice)
+- [FilterMapToSlice](#FilterMapToSlice)
+- [FilterKeys](#FilterKeys)
+- [FilterValues](#FilterValues)
 
 Supported math helpers:
 
 - [Range / RangeFrom / RangeWithSteps](#range--rangefrom--rangewithsteps)
 - [Clamp](#clamp)
+- [Sum](#sum)
 - [SumBy](#sumby)
+- [Product](#product)
+- [ProductBy](#productby)
+- [Mean](#mean)
+- [MeanBy](#meanby)
+- [Mode](#mode)
 
 Supported helpers for strings:
 
+- [RandomString](#randomstring)
 - [Substring](#substring)
 - [ChunkString](#chunkstring)
 - [RuneLength](#runelength)
+- [PascalCase](#pascalcase)
+- [CamelCase](#camelcase)
+- [KebabCase](#kebabcase)
+- [SnakeCase](#snakecase)
+- [Words](#words)
+- [Capitalize](#capitalize)
+- [Ellipsis](#ellipsis)
 
 Supported helpers for tuples:
 
 - [T2 -> T9](#t2---t9)
 - [Unpack2 -> Unpack9](#unpack2---unpack9)
 - [Zip2 -> Zip9](#zip2---zip9)
+- [ZipBy2 -> ZipBy9](#zipby2---zipby9)
 - [Unzip2 -> Unzip9](#unzip2---unzip9)
+- [UnzipBy2 -> UnzipBy9](#unzipby2---unzipby9)
+- [CrossJoin2 -> CrossJoin2](#crossjoin2---crossjoin9)
+- [CrossJoinBy2 -> CrossJoinBy2](#crossjoinby2---crossjoinby9)
+
+Supported helpers for time and duration:
+
+- [Duration](#duration)
+- [Duration0 -> Duration10](#duration0---duration10)
 
 Supported helpers for channels:
 
 - [ChannelDispatcher](#channeldispatcher)
 - [SliceToChannel](#slicetochannel)
+- [ChannelToSlice](#channeltoslice)
 - [Generator](#generator)
-- [Batch](#batch)
-- [BatchWithTimeout](#batchwithtimeout)
+- [Buffer](#buffer)
+- [BufferWithContext](#bufferwithcontext)
+- [BufferWithTimeout](#bufferwithtimeout)
+- [FanIn](#fanin)
+- [FanOut](#fanout)
 
 Supported intersection helpers:
 
@@ -151,18 +256,26 @@ Supported intersection helpers:
 - [None](#none)
 - [NoneBy](#noneby)
 - [Intersect](#intersect)
+- [IntersectBy](#intersectby)
 - [Difference](#difference)
 - [Union](#union)
 - [Without](#without)
+- [WithoutBy](#withoutby)
 - [WithoutEmpty](#withoutempty)
+- [WithoutNth](#withoutnth)
+- [ElementsMatch](#ElementsMatch)
+- [ElementsMatchBy](#ElementsMatchBy)
 
 Supported search helpers:
 
 - [IndexOf](#indexof)
 - [LastIndexOf](#lastindexof)
+- [HasPrefix](#hasprefix)
+- [HasSuffix](#hassuffix)
 - [Find](#find)
 - [FindIndexOf](#findindexof)
 - [FindLastIndexOf](#findlastindexof)
+- [FindOrElse](#findorelse)
 - [FindKey](#findkey)
 - [FindKeyBy](#findkeyby)
 - [FindUniques](#finduniques)
@@ -170,13 +283,30 @@ Supported search helpers:
 - [FindDuplicates](#findduplicates)
 - [FindDuplicatesBy](#findduplicatesby)
 - [Min](#min)
+- [MinIndex](#minindex)
 - [MinBy](#minby)
+- [MinIndexBy](#minindexby)
+- [Earliest](#earliest)
+- [EarliestBy](#earliestby)
 - [Max](#max)
+- [MaxIndex](#maxindex)
 - [MaxBy](#maxby)
+- [MaxIndexBy](#maxindexby)
+- [Latest](#latest)
+- [LatestBy](#latestby)
+- [First](#first)
+- [FirstOrEmpty](#FirstOrEmpty)
+- [FirstOr](#FirstOr)
 - [Last](#last)
+- [LastOrEmpty](#LastOrEmpty)
+- [LastOr](#LastOr)
 - [Nth](#nth)
+- [NthOr](#nthor)
+- [NthOrEmpty](#nthorempty)
 - [Sample](#sample)
+- [SampleBy](#sampleby)
 - [Samples](#samples)
+- [SamplesBy](#samplesby)
 
 Conditional helpers:
 
@@ -187,28 +317,51 @@ Conditional helpers:
 
 Type manipulation helpers:
 
+- [IsNil](#isnil)
+- [IsNotNil](#isnotnil)
 - [ToPtr](#toptr)
+- [Nil](#nil)
+- [EmptyableToPtr](#emptyabletoptr)
 - [FromPtr](#fromptr)
 - [FromPtrOr](#fromptror)
 - [ToSlicePtr](#tosliceptr)
+- [FromSlicePtr](#fromsliceptr)
+- [FromSlicePtrOr](#fromsliceptror)
 - [ToAnySlice](#toanyslice)
 - [FromAnySlice](#fromanyslice)
 - [Empty](#empty)
 - [IsEmpty](#isempty)
 - [IsNotEmpty](#isnotempty)
 - [Coalesce](#coalesce)
+- [CoalesceOrEmpty](#coalesceorempty)
+- [CoalesceSlice](#coalesceslice)
+- [CoalesceSliceOrEmpty](#coalescesliceorempty)
+- [CoalesceMap](#coalescemap)
+- [CoalesceMapOrEmpty](#coalescemaporempty)
 
 Function helpers:
 
 - [Partial](#partial)
+- [Partial2 -> Partial5](#partial2---partial5)
 
 Concurrency helpers:
 
 - [Attempt](#attempt)
+- [AttemptWhile](#attemptwhile)
 - [AttemptWithDelay](#attemptwithdelay)
+- [AttemptWhileWithDelay](#attemptwhilewithdelay)
 - [Debounce](#debounce)
+- [DebounceBy](#debounceby)
+- [Throttle](#throttle)
+- [ThrottleWithCount](#throttle)
+- [ThrottleBy](#throttle)
+- [ThrottleByWithCount](#throttle)
 - [Synchronize](#synchronize)
 - [Async](#async)
+- [Async{0->6}](#async0-6)
+- [Transaction](#transaction)
+- [WaitFor](#waitfor)
+- [WaitForWithContext](#waitforwithcontext)
 
 Error handling:
 
@@ -222,6 +375,8 @@ Error handling:
 - [TryWithErrorValue](#trywitherrorvalue)
 - [TryCatchWithErrorValue](#trycatchwitherrorvalue)
 - [ErrorsAs](#errorsas)
+- [Assert](#assert)
+- [Assertf](#assertf)
 
 Constraints:
 
@@ -229,17 +384,45 @@ Constraints:
 
 ### Filter
 
-Iterates over a collection and returns an array of all the elements the predicate function returns `true` for.
+Iterates over a collection and returns a slice of all the elements the predicate function returns `true` for.
 
 ```go
-even := lo.Filter[int]([]int{1, 2, 3, 4}, func(x int, index int) bool {
+even := lo.Filter([]int{1, 2, 3, 4}, func(x int, index int) bool {
     return x%2 == 0
 })
 // []int{2, 4}
 ```
 
+```go
+// Use FilterErr when the predicate can return an error
+even, err := lo.FilterErr([]int{1, 2, 3, 4}, func(x int, _ int) (bool, error) {
+    if x == 3 {
+        return false, fmt.Errorf("number 3 is not allowed")
+    }
+    return x%2 == 0, nil
+})
+// []int(nil), error("number 3 is not allowed")
+```
+
 [[play](https://go.dev/play/p/Apjg3WeSi7K)]
 
+Mutable: like `lo.Filter()`, but the slice is updated in place.
+
+```go
+import lom "github.com/samber/lo/mutable"
+
+list := []int{1, 2, 3, 4}
+newList := lom.Filter(list, func(x int) bool {
+    return x%2 == 0
+})
+
+list
+// []int{2, 4, 3, 4}
+
+newList
+// []int{2, 4}
+```
+
 ### Map
 
 Manipulates a slice of one type and transforms it into a slice of another type:
@@ -247,33 +430,79 @@ Manipulates a slice of one type and transforms it into a slice of another type:
 ```go
 import "github.com/samber/lo"
 
-lo.Map[int64, string]([]int64{1, 2, 3, 4}, func(x int64, index int) string {
+lo.Map([]int64{1, 2, 3, 4}, func(x int64, index int) string {
     return strconv.FormatInt(x, 10)
 })
 // []string{"1", "2", "3", "4"}
 ```
 
+```go
+// Use MapErr when the transform function can return an error
+result, err := lo.MapErr([]int{1, 2, 3, 4}, func(x int, _ int) (string, error) {
+    if x == 3 {
+        return "", fmt.Errorf("number 3 is not allowed")
+    }
+    return strconv.Itoa(x), nil
+})
+// []string(nil), error("number 3 is not allowed")
+```
+
 [[play](https://go.dev/play/p/OkPcYAhBo0D)]
 
-Parallel processing: like `lo.Map()`, but the mapper function is called in a goroutine. Results are returned in the same order.
+Parallel processing: like `lo.Map()`, but the transform function is called in a goroutine. Results are returned in the same order.
 
 ```go
 import lop "github.com/samber/lo/parallel"
 
-lop.Map[int64, string]([]int64{1, 2, 3, 4}, func(x int64, _ int) string {
+lop.Map([]int64{1, 2, 3, 4}, func(x int64, _ int) string {
     return strconv.FormatInt(x, 10)
 })
 // []string{"1", "2", "3", "4"}
 ```
 
+[[play](https://go.dev/play/p/sCJaB3quRMC)]
+
+Mutable: like `lo.Map()`, but the slice is updated in place.
+
+```go
+import lom "github.com/samber/lo/mutable"
+
+list := []int{1, 2, 3, 4}
+lom.Map(list, func(x int) int {
+    return x*2
+})
+// []int{2, 4, 6, 8}
+```
+
+[[play](https://go.dev/play/p/0jY3Z0B7O_5)]
+
+### UniqMap
+
+Manipulates a slice and transforms it to a slice of another type with unique values.
+
+```go
+type User struct {
+    Name string
+    Age  int
+}
+users := []User{{Name: "Alex", Age: 10}, {Name: "Alex", Age: 12}, {Name: "Bob", Age: 11}, {Name: "Alice", Age: 20}}
+
+names := lo.UniqMap(users, func(u User, index int) string {
+    return u.Name
+})
+// []string{"Alex", "Bob", "Alice"}
+```
+
+[[play](https://go.dev/play/p/fygzLBhvUdB)]
+
 ### FilterMap
 
-Returns a slice which obtained after both filtering and mapping using the given callback function.
+Returns a slice obtained after both filtering and mapping using the given callback function.
 
 The callback function should return two values: the result of the mapping operation and whether the result element should be included or not.
 
 ```go
-matching := lo.FilterMap[string, string]([]string{"cpu", "gpu", "mouse", "keyboard"}, func(x string, _ int) (string, bool) {
+matching := lo.FilterMap([]string{"cpu", "gpu", "mouse", "keyboard"}, func(x string, _ int) (string, bool) {
     if strings.HasSuffix(x, "pu") {
         return "xpu", true
     }
@@ -286,18 +515,29 @@ matching := lo.FilterMap[string, string]([]string{"cpu", "gpu", "mouse", "keyboa
 
 ### FlatMap
 
-Manipulates a slice and transforms and flattens it to a slice of another type.
+Manipulates a slice and transforms and flattens it to a slice of another type. The transform function can either return a slice or a `nil`, and in the `nil` case no value is added to the final slice.
 
 ```go
-lo.FlatMap[int, string]([]int{0, 1, 2}, func(x int, _ int) []string {
-	return []string{
-		strconv.FormatInt(x, 10),
-		strconv.FormatInt(x, 10),
-	}
+lo.FlatMap([]int64{0, 1, 2}, func(x int64, _ int) []string {
+    return []string{
+        strconv.FormatInt(x, 10),
+        strconv.FormatInt(x, 10),
+    }
 })
 // []string{"0", "0", "1", "1", "2", "2"}
 ```
 
+```go
+// Use FlatMapErr when the transform function can return an error
+result, err := lo.FlatMapErr([]int64{0, 1, 2, 3}, func(x int64, _ int) ([]string, error) {
+    if x == 2 {
+        return nil, fmt.Errorf("number 2 is not allowed")
+    }
+    return []string{strconv.FormatInt(x, 10), strconv.FormatInt(x, 10)}, nil
+})
+// []string(nil), error("number 2 is not allowed")
+```
+
 [[play](https://go.dev/play/p/YSoYmQTA8-U)]
 
 ### Reduce
@@ -305,12 +545,23 @@ lo.FlatMap[int, string]([]int{0, 1, 2}, func(x int, _ int) []string {
 Reduces a collection to a single value. The value is calculated by accumulating the result of running each element in the collection through an accumulator function. Each successive invocation is supplied with the return value returned by the previous call.
 
 ```go
-sum := lo.Reduce[int, int]([]int{1, 2, 3, 4}, func(agg int, item int, _ int) int {
+sum := lo.Reduce([]int{1, 2, 3, 4}, func(agg int, item int, _ int) int {
     return agg + item
 }, 0)
 // 10
 ```
 
+```go
+// Use ReduceErr when the accumulator function can return an error
+result, err := lo.ReduceErr([]int{1, 2, 3, 4}, func(agg int, item int, _ int) (int, error) {
+    if item == 3 {
+        return 0, fmt.Errorf("number 3 is not allowed")
+    }
+    return agg + item, nil
+}, 0)
+// 0, error("number 3 is not allowed")
+```
+
 [[play](https://go.dev/play/p/R4UHXZNaaUG)]
 
 ### ReduceRight
@@ -318,12 +569,23 @@ sum := lo.Reduce[int, int]([]int{1, 2, 3, 4}, func(agg int, item int, _ int) int
 Like `lo.Reduce` except that it iterates over elements of collection from right to left.
 
 ```go
-result := lo.ReduceRight[[]int, []int]([][]int{{0, 1}, {2, 3}, {4, 5}}, func(agg []int, item []int, _ int) []int {
-	  return append(agg, item...)
+result := lo.ReduceRight([][]int{{0, 1}, {2, 3}, {4, 5}}, func(agg []int, item []int, _ int) []int {
+    return append(agg, item...)
 }, []int{})
 // []int{4, 5, 2, 3, 0, 1}
 ```
 
+```go
+// Use ReduceRightErr when the accumulator function can return an error
+result, err := lo.ReduceRightErr([]int{1, 2, 3, 4}, func(agg int, item int, _ int) (int, error) {
+    if item == 2 {
+        return 0, fmt.Errorf("number 2 is not allowed")
+    }
+    return agg + item, nil
+}, 0)
+// 0, error("number 2 is not allowed")
+```
+
 [[play](https://go.dev/play/p/Fq3W70l7wXF)]
 
 ### ForEach
@@ -333,7 +595,7 @@ Iterates over elements of a collection and invokes the function over each elemen
 ```go
 import "github.com/samber/lo"
 
-lo.ForEach[string]([]string{"hello", "world"}, func(x string, _ int) {
+lo.ForEach([]string{"hello", "world"}, func(x string, _ int) {
     println(x)
 })
 // prints "hello\nworld\n"
@@ -346,20 +608,40 @@ Parallel processing: like `lo.ForEach()`, but the callback is called as a gorout
 ```go
 import lop "github.com/samber/lo/parallel"
 
-lop.ForEach[string]([]string{"hello", "world"}, func(x string, _ int) {
+lop.ForEach([]string{"hello", "world"}, func(x string, _ int) {
     println(x)
 })
 // prints "hello\nworld\n" or "world\nhello\n"
 ```
 
+### ForEachWhile
+
+Iterates over collection elements and invokes iteratee for each element collection return value decide to continue or break, like do while().
+
+```go
+list := []int64{1, 2, -42, 4}
+
+lo.ForEachWhile(list, func(x int64, _ int) bool {
+	if x < 0 {
+		return false
+	}
+	fmt.Println(x)
+	return true
+})
+// 1
+// 2
+```
+
+[[play](https://go.dev/play/p/QnLGt35tnow)]
+
 ### Times
 
-Times invokes the iteratee n times, returning an array of the results of each invocation. The iteratee is invoked with index as argument.
+Times invokes the iteratee n times, returning a slice of the results of each invocation. The iteratee is invoked with index as argument.
 
 ```go
 import "github.com/samber/lo"
 
-lo.Times[string](3, func(i int) string {
+lo.Times(3, func(i int) string {
     return strconv.FormatInt(int64(i), 10)
 })
 // []string{"0", "1", "2"}
@@ -372,7 +654,7 @@ Parallel processing: like `lo.Times()`, but callback is called in goroutine.
 ```go
 import lop "github.com/samber/lo/parallel"
 
-lop.Times[string](3, func(i int) string {
+lop.Times(3, func(i int) string {
     return strconv.FormatInt(int64(i), 10)
 })
 // []string{"0", "1", "2"}
@@ -380,10 +662,10 @@ lop.Times[string](3, func(i int) string {
 
 ### Uniq
 
-Returns a duplicate-free version of an array, in which only the first occurrence of each element is kept. The order of result values is determined by the order they occur in the array.
+Returns a duplicate-free version of a slice, in which only the first occurrence of each element is kept. The order of result values is determined by the order they occur in the slice.
 
 ```go
-uniqValues := lo.Uniq[int]([]int{1, 2, 2, 1})
+uniqValues := lo.Uniq([]int{1, 2, 2, 1})
 // []int{1, 2}
 ```
 
@@ -391,15 +673,26 @@ uniqValues := lo.Uniq[int]([]int{1, 2, 2, 1})
 
 ### UniqBy
 
-Returns a duplicate-free version of an array, in which only the first occurrence of each element is kept. The order of result values is determined by the order they occur in the array. It accepts `iteratee` which is invoked for each element in array to generate the criterion by which uniqueness is computed.
+Returns a duplicate-free version of a slice, in which only the first occurrence of each element is kept. The order of result values is determined by the order they occur in the slice. It accepts `iteratee` which is invoked for each element in the slice to generate the criterion by which uniqueness is computed.
 
 ```go
-uniqValues := lo.UniqBy[int, int]([]int{0, 1, 2, 3, 4, 5}, func(i int) int {
+uniqValues := lo.UniqBy([]int{0, 1, 2, 3, 4, 5}, func(i int) int {
     return i%3
 })
 // []int{0, 1, 2}
 ```
 
+```go
+// Use UniqByErr when the iteratee function can return an error
+result, err := lo.UniqByErr([]int{0, 1, 2, 3, 4, 5}, func(i int) (int, error) {
+    if i == 3 {
+        return 0, fmt.Errorf("number 3 is not allowed")
+    }
+    return i % 3, nil
+})
+// []int(nil), error("number 3 is not allowed")
+```
+
 [[play](https://go.dev/play/p/g42Z3QSb53u)]
 
 ### GroupBy
@@ -409,12 +702,23 @@ Returns an object composed of keys generated from the results of running each el
 ```go
 import lo "github.com/samber/lo"
 
-groups := lo.GroupBy[int, int]([]int{0, 1, 2, 3, 4, 5}, func(i int) int {
+groups := lo.GroupBy([]int{0, 1, 2, 3, 4, 5}, func(i int) int {
     return i%3
 })
 // map[int][]int{0: []int{0, 3}, 1: []int{1, 4}, 2: []int{2, 5}}
 ```
 
+```go
+// Use GroupByErr when the iteratee function can return an error
+result, err := lo.GroupByErr([]int{0, 1, 2, 3, 4, 5}, func(i int) (int, error) {
+    if i == 3 {
+        return 0, fmt.Errorf("number 3 is not allowed")
+    }
+    return i % 3, nil
+})
+// map[int][]int(nil), error("number 3 is not allowed")
+```
+
 [[play](https://go.dev/play/p/XnQBd_v6brd)]
 
 Parallel processing: like `lo.GroupBy()`, but callback is called in goroutine.
@@ -422,40 +726,96 @@ Parallel processing: like `lo.GroupBy()`, but callback is called in goroutine.
 ```go
 import lop "github.com/samber/lo/parallel"
 
-lop.GroupBy[int, int]([]int{0, 1, 2, 3, 4, 5}, func(i int) int {
+lop.GroupBy([]int{0, 1, 2, 3, 4, 5}, func(i int) int {
     return i%3
 })
 // map[int][]int{0: []int{0, 3}, 1: []int{1, 4}, 2: []int{2, 5}}
 ```
 
+### GroupByMap
+
+Returns an object composed of keys generated from the results of running each element of collection through iteratee.
+
+```go
+import lo "github.com/samber/lo"
+
+groups := lo.GroupByMap([]int{0, 1, 2, 3, 4, 5}, func(i int) (int, int) {
+    return i%3, i*2
+})
+// map[int][]int{0: []int{0, 6}, 1: []int{2, 8}, 2: []int{4, 10}}
+```
+
+```go
+// Use GroupByMapErr when the transform function can return an error
+result, err := lo.GroupByMapErr([]int{0, 1, 2, 3, 4, 5}, func(i int) (int, int, error) {
+    if i == 3 {
+        return 0, 0, fmt.Errorf("number 3 is not allowed")
+    }
+    return i % 3, i * 2, nil
+})
+// map[int][]int(nil), error("number 3 is not allowed")
+```
+
+[[play](https://go.dev/play/p/iMeruQ3_W80)]
+
 ### Chunk
 
-Returns an array of elements split into groups the length of size. If array can't be split evenly, the final chunk will be the remaining elements.
+Returns a slice of elements split into groups of length size. If the slice can't be split evenly, the final chunk will be the remaining elements.
 
 ```go
-lo.Chunk[int]([]int{0, 1, 2, 3, 4, 5}, 2)
+lo.Chunk([]int{0, 1, 2, 3, 4, 5}, 2)
 // [][]int{{0, 1}, {2, 3}, {4, 5}}
 
-lo.Chunk[int]([]int{0, 1, 2, 3, 4, 5, 6}, 2)
+lo.Chunk([]int{0, 1, 2, 3, 4, 5, 6}, 2)
 // [][]int{{0, 1}, {2, 3}, {4, 5}, {6}}
 
-lo.Chunk[int]([]int{}, 2)
+lo.Chunk([]int{}, 2)
 // [][]int{}
 
-lo.Chunk[int]([]int{0}, 2)
+lo.Chunk([]int{0}, 2)
 // [][]int{{0}}
 ```
 
-[[play](https://go.dev/play/p/EeKl0AuTehH)]
+[[play](https://go.dev/play/p/kEMkFbdu85g)]
+
+### Window
+
+Creates a slice of sliding windows of a given size. Each window shares size-1 elements with the previous one. This is equivalent to `Sliding(collection, size, 1)`.
+
+```go
+lo.Window([]int{1, 2, 3, 4, 5}, 3)
+// [][]int{{1, 2, 3}, {2, 3, 4}, {3, 4, 5}}
+
+lo.Window([]float64{20, 22, 21, 23, 24}, 3)
+// [][]float64{{20, 22, 21}, {22, 21, 23}, {21, 23, 24}}
+```
+
+### Sliding
+
+Creates a slice of sliding windows of a given size with a given step. If step is equal to size, windows have no common elements (similar to Chunk). If step is less than size, windows share common elements.
+
+```go
+// Windows with shared elements (step < size)
+lo.Sliding([]int{1, 2, 3, 4, 5, 6}, 3, 1)
+// [][]int{{1, 2, 3}, {2, 3, 4}, {3, 4, 5}, {4, 5, 6}}
+
+// Windows with no shared elements (step == size, like Chunk)
+lo.Sliding([]int{1, 2, 3, 4, 5, 6}, 3, 3)
+// [][]int{{1, 2, 3}, {4, 5, 6}}
+
+// Step > size (skipping elements)
+lo.Sliding([]int{1, 2, 3, 4, 5, 6, 7, 8}, 2, 3)
+// [][]int{{1, 2}, {4, 5}, {7, 8}}
+```
 
 ### PartitionBy
 
-Returns an array of elements split into groups. The order of grouped values is determined by the order they occur in collection. The grouping is generated from the results of running each element of collection through iteratee.
+Returns a slice of elements split into groups. The order of grouped values is determined by the order they occur in collection. The grouping is generated from the results of running each element of collection through iteratee.
 
 ```go
 import lo "github.com/samber/lo"
 
-partitions := lo.PartitionBy[int, string]([]int{-2, -1, 0, 1, 2, 3, 4, 5}, func(x int) string {
+partitions := lo.PartitionBy([]int{-2, -1, 0, 1, 2, 3, 4, 5}, func(x int) string {
     if x < 0 {
         return "negative"
     } else if x%2 == 0 {
@@ -466,6 +826,22 @@ partitions := lo.PartitionBy[int, string]([]int{-2, -1, 0, 1, 2, 3, 4, 5}, func(
 // [][]int{{-2, -1}, {0, 2, 4}, {1, 3, 5}}
 ```
 
+```go
+// Use PartitionByErr when the iteratee function can return an error
+result, err := lo.PartitionByErr([]int{-2, -1, 0, 1, 2}, func(x int) (string, error) {
+    if x == 0 {
+        return "", fmt.Errorf("zero is not allowed")
+    }
+    if x < 0 {
+        return "negative", nil
+    } else if x%2 == 0 {
+        return "even", nil
+    }
+    return "odd", nil
+})
+// [][]int(nil), error("zero is not allowed")
+```
+
 [[play](https://go.dev/play/p/NfQ_nGjkgXW)]
 
 Parallel processing: like `lo.PartitionBy()`, but callback is called in goroutine. Results are returned in the same order.
@@ -473,7 +849,7 @@ Parallel processing: like `lo.PartitionBy()`, but callback is called in goroutin
 ```go
 import lop "github.com/samber/lo/parallel"
 
-partitions := lop.PartitionBy[int, string]([]int{-2, -1, 0, 1, 2, 3, 4, 5}, func(x int) string {
+partitions := lop.PartitionBy([]int{-2, -1, 0, 1, 2, 3, 4, 5}, func(x int) string {
     if x < 0 {
         return "negative"
     } else if x%2 == 0 {
@@ -486,51 +862,93 @@ partitions := lop.PartitionBy[int, string]([]int{-2, -1, 0, 1, 2, 3, 4, 5}, func
 
 ### Flatten
 
-Returns an array a single level deep.
+Returns a slice a single level deep.
 
 ```go
-flat := lo.Flatten[int]([][]int{{0, 1}, {2, 3, 4, 5}})
+flat := lo.Flatten([][]int{{0, 1}, {2, 3, 4, 5}})
 // []int{0, 1, 2, 3, 4, 5}
 ```
 
 [[play](https://go.dev/play/p/rbp9ORaMpjw)]
 
+### Concat
+
+Returns a new slice containing all the elements in collections. Concat conserves the order of the elements.
+
+```go
+slice := lo.Concat([]int{1, 2}, []int{3, 4})
+// []int{1, 2, 3, 4}
+
+slice := lo.Concat(nil, []int{1, 2}, nil, []int{3, 4}, nil)
+// []int{1, 2, 3, 4}
+
+slice := lo.Concat[int]()
+// []int{}
+```
+### Interleave
+
+Round-robin alternating input slices and sequentially appending value at index into result.
+
+```go
+interleaved := lo.Interleave([]int{1, 4, 7}, []int{2, 5, 8}, []int{3, 6, 9})
+// []int{1, 2, 3, 4, 5, 6, 7, 8, 9}
+
+interleaved := lo.Interleave([]int{1}, []int{2, 5, 8}, []int{3, 6}, []int{4, 7, 9, 10})
+// []int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}
+```
+
+[[play](https://go.dev/play/p/-RJkTLQEDVt)]
+
 ### Shuffle
 
-Returns an array of shuffled values. Uses the Fisher-Yates shuffle algorithm.
+Returns a slice of shuffled values. Uses the Fisher-Yates shuffle algorithm.
+
+⚠️ This helper is **mutable**.
 
 ```go
-randomOrder := lo.Shuffle[int]([]int{0, 1, 2, 3, 4, 5})
+import lom "github.com/samber/lo/mutable"
+
+list := []int{0, 1, 2, 3, 4, 5}
+lom.Shuffle(list)
+
+list
 // []int{1, 4, 0, 3, 5, 2}
 ```
 
-[[play](https://go.dev/play/p/Qp73bnTDnc7)]
+[[play](https://go.dev/play/p/2xb3WdLjeSJ)]
 
 ### Reverse
 
-Reverses array so that the first element becomes the last, the second element becomes the second to last, and so on.
+Reverses a slice so that the first element becomes the last, the second element becomes the second to last, and so on.
+
+⚠️ This helper is **mutable**.
 
 ```go
-reverseOrder := lo.Reverse[int]([]int{0, 1, 2, 3, 4, 5})
+import lom "github.com/samber/lo/mutable"
+
+list := []int{0, 1, 2, 3, 4, 5}
+lom.Reverse(list)
+
+list
 // []int{5, 4, 3, 2, 1, 0}
 ```
 
-[[play](https://go.dev/play/p/fhUMLvZ7vS6)]
+[[play](https://go.dev/play/p/O-M5pmCRgzV)]
 
 ### Fill
 
-Fills elements of array with `initial` value.
+Fills elements of a slice with `initial` value.
 
 ```go
 type foo struct {
-	bar string
+  bar string
 }
 
 func (f foo) Clone() foo {
-	return foo{f.bar}
+  return foo{f.bar}
 }
 
-initializedSlice := lo.Fill[foo]([]foo{foo{"a"}, foo{"a"}}, foo{"b"})
+initializedSlice := lo.Fill([]foo{foo{"a"}, foo{"a"}}, foo{"b"})
 // []foo{foo{"b"}, foo{"b"}}
 ```
 
@@ -542,14 +960,14 @@ Builds a slice with N copies of initial value.
 
 ```go
 type foo struct {
-	bar string
+  bar string
 }
 
 func (f foo) Clone() foo {
-	return foo{f.bar}
+  return foo{f.bar}
 }
 
-slice := lo.Repeat[foo](2, foo{"a"})
+slice := lo.Repeat(2, foo{"a"})
 // []foo{foo{"a"}, foo{"a"}}
 ```
 
@@ -560,69 +978,167 @@ slice := lo.Repeat[foo](2, foo{"a"})
 Builds a slice with values returned by N calls of callback.
 
 ```go
-slice := lo.RepeatBy[string](0, func (i int) string {
+slice := lo.RepeatBy(0, func (i int) string {
     return strconv.FormatInt(int64(math.Pow(float64(i), 2)), 10)
 })
-// []int{}
+// []string{}
 
-slice := lo.RepeatBy[string](5, func(i int) string {
+slice := lo.RepeatBy(5, func(i int) string {
     return strconv.FormatInt(int64(math.Pow(float64(i), 2)), 10)
 })
-// []int{0, 1, 4, 9, 16}
+// []string{"0", "1", "4", "9", "16"}
 ```
 
 [[play](https://go.dev/play/p/ozZLCtX_hNU)]
 
+With error handling:
+
+```go
+slice, err := lo.RepeatByErr(5, func(i int) (string, error) {
+    if i == 3 {
+        return "", fmt.Errorf("index 3 is not allowed")
+    }
+    return fmt.Sprintf("item-%d", i), nil
+})
+// []string(nil), error("index 3 is not allowed")
+```
+
 ### KeyBy
 
-Transforms a slice or an array of structs to a map based on a pivot callback.
+Transforms a slice or a slice of structs to a map based on a pivot callback.
 
 ```go
-m := lo.KeyBy[int, string]([]string{"a", "aa", "aaa"}, func(str string) int {
+m := lo.KeyBy([]string{"a", "aa", "aaa"}, func(str string) int {
     return len(str)
 })
 // map[int]string{1: "a", 2: "aa", 3: "aaa"}
 
 type Character struct {
-	dir  string
-	code int
+  dir  string
+  code int
 }
 characters := []Character{
     {dir: "left", code: 97},
     {dir: "right", code: 100},
 }
-result := lo.KeyBy[string, Character](characters, func(char Character) string {
+result := lo.KeyBy(characters, func(char Character) string {
     return string(rune(char.code))
 })
 //map[a:{dir:left code:97} d:{dir:right code:100}]
 ```
 
+```go
+result, err := lo.KeyByErr([]string{"a", "aa", "aaa", ""}, func(str string) (int, error) {
+    if str == "" {
+        return 0, fmt.Errorf("empty string not allowed")
+    }
+    return len(str), nil
+})
+// map[int]string(nil), error("empty string not allowed")
+```
+
 [[play](https://go.dev/play/p/mdaClUAT-zZ)]
 
-### Associate (alias: SliceToMap)
+### SliceToMap (alias: Associate)
 
 Returns a map containing key-value pairs provided by transform function applied to elements of the given slice.
-If any of two pairs would have the same key the last one gets added to the map.
+If any of two pairs have the same key the last one gets added to the map.
 
-The order of keys in returned map is not specified and is not guaranteed to be the same from the original array.
+The order of keys in returned map is not specified and is not guaranteed to be the same from the original slice.
 
 ```go
 in := []*foo{{baz: "apple", bar: 1}, {baz: "banana", bar: 2}}
 
-aMap := lo.Associate[*foo, string, int](in, func (f *foo) (string, int) {
-	return f.baz, f.bar
+aMap := lo.SliceToMap(in, func (f *foo) (string, int) {
+    return f.baz, f.bar
 })
 // map[string][int]{ "apple":1, "banana":2 }
 ```
 
 [[play](https://go.dev/play/p/WHa2CfMO3Lr)]
 
+### FilterSliceToMap
+
+Returns a map containing key-value pairs provided by transform function applied to elements of the given slice.
+
+If any of two pairs have the same key the last one gets added to the map.
+
+The order of keys in returned map is not specified and is not guaranteed to be the same from the original slice.
+
+The third return value of the transform function is a boolean that indicates whether the key-value pair should be included in the map.
+
+```go
+list := []string{"a", "aa", "aaa"}
+
+result := lo.FilterSliceToMap(list, func(str string) (string, int, bool) {
+    return str, len(str), len(str) > 1
+})
+// map[string][int]{"aa":2 "aaa":3}
+```
+
+[[play](https://go.dev/play/p/2z0rDz2ZSGU)]
+
+### Keyify
+
+Returns a map with each unique element of the slice as a key.
+
+```go
+set := lo.Keyify([]int{1, 1, 2, 3, 4})
+// map[int]struct{}{1:{}, 2:{}, 3:{}, 4:{}}
+```
+
+[[play](https://go.dev/play/p/RYhhM_csqIG)]
+
+### Take
+
+Takes the first n elements from a slice.
+
+```go
+l := lo.Take([]int{0, 1, 2, 3, 4, 5}, 3)
+// []int{0, 1, 2}
+
+l := lo.Take([]int{0, 1, 2}, 5)
+// []int{0, 1, 2}
+```
+
+### TakeWhile
+
+Takes elements from the beginning while the predicate returns true.
+
+```go
+l := lo.TakeWhile([]int{0, 1, 2, 3, 4, 5}, func(val int) bool {
+    return val < 3
+})
+// []int{0, 1, 2}
+
+l := lo.TakeWhile([]string{"a", "aa", "aaa", "aa"}, func(val string) bool {
+    return len(val) <= 2
+})
+// []string{"a", "aa"}
+```
+
+### TakeFilter
+
+Filters elements and takes the first n elements that match the predicate. Equivalent to calling Take(Filter(...)), but more efficient as it stops after finding n matches.
+
+```go
+l := lo.TakeFilter([]int{1, 2, 3, 4, 5, 6, 7, 8, 9, 10}, 3, func(val int, index int) bool {
+    return val%2 == 0
+})
+// []int{2, 4, 6}
+
+l := lo.TakeFilter([]string{"a", "aa", "aaa", "aaaa"}, 2, func(val string, index int) bool {
+    return len(val) > 1
+})
+// []string{"aa", "aaa"}
+```
+
 ### Drop
 
-Drops n elements from the beginning of a slice or array.
+Drops n elements from the beginning of a slice.
 
 ```go
-l := lo.Drop[int]([]int{0, 1, 2, 3, 4, 5}, 2)
+l := lo.Drop([]int{0, 1, 2, 3, 4, 5}, 2)
 // []int{2, 3, 4, 5}
 ```
 
@@ -630,10 +1146,10 @@ l := lo.Drop[int]([]int{0, 1, 2, 3, 4, 5}, 2)
 
 ### DropRight
 
-Drops n elements from the end of a slice or array.
+Drops n elements from the end of a slice.
 
 ```go
-l := lo.DropRight[int]([]int{0, 1, 2, 3, 4, 5}, 2)
+l := lo.DropRight([]int{0, 1, 2, 3, 4, 5}, 2)
 // []int{0, 1, 2, 3}
 ```
 
@@ -641,11 +1157,11 @@ l := lo.DropRight[int]([]int{0, 1, 2, 3, 4, 5}, 2)
 
 ### DropWhile
 
-Drop elements from the beginning of a slice or array while the predicate returns true.
+Drop elements from the beginning of a slice while the predicate returns true.
 
 ```go
-l := lo.DropWhile[string]([]string{"a", "aa", "aaa", "aa", "aa"}, func(val string) bool {
-	return len(val) <= 2
+l := lo.DropWhile([]string{"a", "aa", "aaa", "aa", "aa"}, func(val string) bool {
+    return len(val) <= 2
 })
 // []string{"aaa", "aa", "aa"}
 ```
@@ -654,36 +1170,86 @@ l := lo.DropWhile[string]([]string{"a", "aa", "aaa", "aa", "aa"}, func(val strin
 
 ### DropRightWhile
 
-Drop elements from the end of a slice or array while the predicate returns true.
+Drop elements from the end of a slice while the predicate returns true.
 
 ```go
-l := lo.DropRightWhile[string]([]string{"a", "aa", "aaa", "aa", "aa"}, func(val string) bool {
-	return len(val) <= 2
+l := lo.DropRightWhile([]string{"a", "aa", "aaa", "aa", "aa"}, func(val string) bool {
+    return len(val) <= 2
 })
 // []string{"a", "aa", "aaa"}
 ```
 
 [[play](https://go.dev/play/p/3-n71oEC0Hz)]
 
+### DropByIndex
+
+Drops elements from a slice by the index. A negative index will drop elements from the end of the slice.
+
+```go
+l := lo.DropByIndex([]int{0, 1, 2, 3, 4, 5}, 2, 4, -1)
+// []int{0, 1, 3}
+```
+
+[[play](https://go.dev/play/p/JswS7vXRJP2)]
+
 ### Reject
 
-The opposite of Filter, this method returns the elements of collection that predicate does not return truthy for.
+The opposite of Filter, this method returns the elements of collection that predicate does not return true for.
 
 ```go
-odd := lo.Reject[int]([]int{1, 2, 3, 4}, func(x int, _ int) bool {
+odd := lo.Reject([]int{1, 2, 3, 4}, func(x int, _ int) bool {
     return x%2 == 0
 })
 // []int{1, 3}
 ```
 
+```go
+// Use RejectErr when the predicate can return an error
+odd, err := lo.RejectErr([]int{1, 2, 3, 4}, func(x int, _ int) (bool, error) {
+    if x == 3 {
+        return false, fmt.Errorf("number 3 is not allowed")
+    }
+    return x%2 == 0, nil
+})
+// []int(nil), error("number 3 is not allowed")
+```
+
 [[play](https://go.dev/play/p/YkLMODy1WEL)]
 
+### RejectMap
+
+The opposite of FilterMap, this method returns a slice obtained after both filtering and mapping using the given callback function.
+
+The callback function should return two values:
+
+- the result of the mapping operation and
+- whether the result element should be included or not.
+
+```go
+items := lo.RejectMap([]int{1, 2, 3, 4}, func(x int, _ int) (int, bool) {
+    return x*10, x%2 == 0
+})
+// []int{10, 30}
+```
+
+### FilterReject
+
+Mixes Filter and Reject, this method returns two slices, one for the elements of collection that predicate returns true for and one for the elements that predicate does not return true for.
+
+```go
+kept, rejected := lo.FilterReject([]int{1, 2, 3, 4}, func(x int, _ int) bool {
+    return x%2 == 0
+})
+// []int{2, 4}
+// []int{1, 3}
+```
+
 ### Count
 
-Counts the number of elements in the collection that compare equal to value.
+Counts the number of elements in the collection that equal value.
 
 ```go
-count := lo.Count[int]([]int{1, 5, 1}, 1)
+count := lo.Count([]int{1, 5, 1}, 1)
 // 2
 ```
 
@@ -694,41 +1260,106 @@ count := lo.Count[int]([]int{1, 5, 1}, 1)
 Counts the number of elements in the collection for which predicate is true.
 
 ```go
-count := lo.CountBy[int]([]int{1, 5, 1}, func(i int) bool {
+count := lo.CountBy([]int{1, 5, 1}, func(i int) bool {
     return i < 4
 })
 // 2
 ```
 
+```go
+// Use CountByErr when the predicate can return an error
+count, err := lo.CountByErr([]int{1, 5, 1}, func(i int) (bool, error) {
+    if i == 5 {
+        return false, fmt.Errorf("5 not allowed")
+    }
+    return i < 4, nil
+})
+// 0, error("5 not allowed")
+```
+
 [[play](https://go.dev/play/p/ByQbNYQQi4X)]
 
-### Subset
+### CountValues
 
-Returns a copy of a slice from `offset` up to `length` elements. Like `slice[start:start+length]`, but does not panic on overflow.
+Counts the number of each element in the collection.
 
 ```go
-in := []int{0, 1, 2, 3, 4}
+lo.CountValues([]int{})
+// map[int]int{}
 
-sub := lo.Subset(in, 2, 3)
-// []int{2, 3, 4}
+lo.CountValues([]int{1, 2})
+// map[int]int{1: 1, 2: 1}
 
-sub := lo.Subset(in, -4, 3)
-// []int{1, 2, 3}
+lo.CountValues([]int{1, 2, 2})
+// map[int]int{1: 1, 2: 2}
 
-sub := lo.Subset(in, -2, math.MaxUint)
-// []int{3, 4}
+lo.CountValues([]string{"foo", "bar", ""})
+// map[string]int{"": 1, "foo": 1, "bar": 1}
+
+lo.CountValues([]string{"foo", "bar", "bar"})
+// map[string]int{"foo": 1, "bar": 2}
 ```
 
-[[play](https://go.dev/play/p/tOQu1GhFcog)]
+[[play](https://go.dev/play/p/-p-PyLT4dfy)]
 
-### Slice
+### CountValuesBy
 
-Returns a copy of a slice from `start` up to, but not including `end`. Like `slice[start:end]`, but does not panic on overflow.
+Counts the number of each element in the collection. It is equivalent to chaining lo.Map and lo.CountValues.
 
 ```go
-in := []int{0, 1, 2, 3, 4}
+isEven := func(v int) bool {
+    return v%2==0
+}
 
-slice := lo.Slice(in, 0, 5)
+lo.CountValuesBy([]int{}, isEven)
+// map[bool]int{}
+
+lo.CountValuesBy([]int{1, 2}, isEven)
+// map[bool]int{false: 1, true: 1}
+
+lo.CountValuesBy([]int{1, 2, 2}, isEven)
+// map[bool]int{false: 1, true: 2}
+
+length := func(v string) int {
+    return len(v)
+}
+
+lo.CountValuesBy([]string{"foo", "bar", ""}, length)
+// map[int]int{0: 1, 3: 2}
+
+lo.CountValuesBy([]string{"foo", "bar", "bar"}, length)
+// map[int]int{3: 3}
+```
+
+[[play](https://go.dev/play/p/2U0dG1SnOmS)]
+
+### Subset
+
+Returns a copy of a slice from `offset` up to `length` elements. Like `slice[start:start+length]`, but does not panic on overflow.
+
+```go
+in := []int{0, 1, 2, 3, 4}
+
+sub := lo.Subset(in, 2, 3)
+// []int{2, 3, 4}
+
+sub := lo.Subset(in, -4, 3)
+// []int{1, 2, 3}
+
+sub := lo.Subset(in, -2, math.MaxUint)
+// []int{3, 4}
+```
+
+[[play](https://go.dev/play/p/tOQu1GhFcog)]
+
+### Slice
+
+Returns a copy of a slice from `start` up to, but not including `end`. Like `slice[start:end]`, but does not panic on overflow.
+
+```go
+in := []int{0, 1, 2, 3, 4}
+
+slice := lo.Slice(in, 0, 5)
 // []int{0, 1, 2, 3, 4}
 
 slice := lo.Slice(in, 2, 3)
@@ -781,6 +1412,20 @@ slice := lo.ReplaceAll(in, -1, 42)
 
 [[play](https://go.dev/play/p/a9xZFUHfYcV)]
 
+### Clone
+
+Returns a shallow copy of the collection.
+
+```go
+in := []int{1, 2, 3, 4, 5}
+cloned := lo.Clone(in)
+// Verify it's a different slice by checking that modifying one doesn't affect the other
+in[0] = 99
+// cloned is []int{1, 2, 3, 4, 5}
+```
+
+[[play](https://go.dev/play/p/hgHmoOIxmuH)]
+
 ### Compact
 
 Returns a slice of all non-zero elements.
@@ -788,7 +1433,7 @@ Returns a slice of all non-zero elements.
 ```go
 in := []string{"", "foo", "", "bar", ""}
 
-slice := lo.Compact[string](in)
+slice := lo.Compact(in)
 // []string{"foo", "bar"}
 ```
 
@@ -805,12 +1450,12 @@ slice := lo.IsSorted([]int{0, 1, 2, 3, 4, 5, 6, 7, 8, 9})
 
 [[play](https://go.dev/play/p/mc3qR-t4mcx)]
 
-### IsSortedByKey
+### IsSortedBy
 
 Checks if a slice is sorted by iteratee.
 
 ```go
-slice := lo.IsSortedByKey([]string{"a", "bb", "ccc"}, func(s string) int {
+slice := lo.IsSortedBy([]string{"a", "bb", "ccc"}, func(s string) int {
     return len(s)
 })
 // true
@@ -818,39 +1463,277 @@ slice := lo.IsSortedByKey([]string{"a", "bb", "ccc"}, func(s string) int {
 
 [[play](https://go.dev/play/p/wiG6XyBBu49)]
 
+### Splice
+
+Splice inserts multiple elements at index i. A negative index counts back from the end of the slice. The helper is protected against overflow errors.
+
+```go
+result := lo.Splice([]string{"a", "b"}, 1, "1", "2")
+// []string{"a", "1", "2", "b"}
+
+// negative
+result = lo.Splice([]string{"a", "b"}, -1, "1", "2")
+// []string{"a", "1", "2", "b"}
+
+// overflow
+result = lo.Splice([]string{"a", "b"}, 42, "1", "2")
+// []string{"a", "b", "1", "2"}
+```
+
+[[play](https://go.dev/play/p/G5_GhkeSUBA)]
+
+### Cut
+
+Slices collection around the first instance of separator, returning the part of collection before and after separator. The found result reports whether separator appears in collection. If separator does not appear in s, cut returns collection, empty slice of []T, false.
+
+```go
+actualLeft, actualRight, result = lo.Cut([]string{"a", "b", "c", "d", "e", "f", "g"}, []string{"b", "c", "d"})
+// actualLeft: []string{"a"}
+// actualRight: []string{"e", "f", "g"}
+// result: true
+
+result = lo.Cut([]string{"a", "b", "c", "d", "e", "f", "g"}, []string{"z"})
+// actualLeft: []string{"a", "b", "c", "d", "e", "f", "g"}
+// actualRight: []string{}
+// result: false
+
+result = lo.Cut([]string{"a", "b", "c", "d", "e", "f", "g"}, []string{"a", "b"})
+// actualLeft: []string{}
+// actualRight: []string{"c", "d", "e", "f", "g"}
+// result: true
+```
+
+[[play](https://go.dev/play/p/GiL3qhpIP3f)]
+
+### CutPrefix
+
+Returns collection without the provided leading prefix []T and reports whether it found the prefix. If s doesn't start with prefix, CutPrefix returns collection, false. If prefix is the empty []T, CutPrefix returns collection, true.
+
+```go
+actualRight, result = lo.CutPrefix([]string{"a", "b", "c", "d", "e", "f", "g"}, []string{"a", "b", "c"})
+// actualRight: []string{"d", "e", "f", "g"}
+// result: true
+
+result = lo.CutPrefix([]string{"a", "b", "c", "d", "e", "f", "g"}, []string{"b"})
+// actualRight: []string{"a", "b", "c", "d", "e", "f", "g"}
+// result: false
+
+result = lo.CutPrefix([]string{"a", "b", "c", "d", "e", "f", "g"}, []string{})
+// actualRight: []string{"a", "b", "c", "d", "e", "f", "g"}
+// result: true
+```
+
+[[play](https://go.dev/play/p/7Plak4a1ICl)]
+
+### CutSuffix
+
+Returns collection without the provided ending suffix []T and reports whether it found the suffix. If it doesn't end with suffix, CutSuffix returns collection, false. If suffix is the empty []T, CutSuffix returns collection, true.
+
+```go
+actualLeft, result = lo.CutSuffix([]string{"a", "b", "c", "d", "e", "f", "g"}, []string{"f", "g"})
+// actualLeft: []string{"a", "b", "c", "d", "e"}
+// result: true
+
+actualLeft, result = lo.CutSuffix([]string{"a", "b", "c", "d", "e", "f", "g"}, []string{"b"})
+// actualLeft: []string{"a", "b", "c", "d", "e", "f", "g"}
+// result: false
+
+actualLeft, result = lo.CutSuffix([]string{"a", "b", "c", "d", "e", "f", "g"}, []string{})
+// actualLeft: []string{"a", "b", "c", "d", "e", "f", "g"}
+// result: true
+```
+
+[[play](https://go.dev/play/p/7FKfBFvPTaT)]
+
+### Trim
+
+Removes all the leading and trailing cutset from the collection.
+
+```go
+result := lo.Trim([]int{0, 1, 2, 0, 3, 0}, []int{1, 0})
+// []int{2, 0, 3}
+
+result := lo.Trim([]string{"hello", "world", " "}, []string{" ", ""})
+// []string{"hello", "world"}
+```
+
+[[play](https://go.dev/play/p/1an9mxLdRG5)]
+
+### TrimLeft
+
+Removes all the leading cutset from the collection.
+
+```go
+result := lo.TrimLeft([]int{0, 1, 2, 0, 3, 0}, []int{1, 0})
+// []int{2, 0, 3, 0}
+
+result := lo.TrimLeft([]string{"hello", "world", " "}, []string{" ", ""})
+// []string{"hello", "world", " "}
+```
+
+[[play](https://go.dev/play/p/74aqfAYLmyi)]
+
+### TrimPrefix
+
+Removes all the leading prefix from the collection.
+
+```go
+result := lo.TrimPrefix([]int{1, 2, 1, 2, 3, 1, 2, 4}, []int{1, 2})
+// []int{3, 1, 2, 4}
+
+result := lo.TrimPrefix([]string{"hello", "world", "hello", "test"}, []string{"hello"})
+// []string{"world", "hello", "test"}
+```
+
+[[play](https://go.dev/play/p/SHO6X-YegPg)]
+
+### TrimRight
+
+Removes all the trailing cutset from the collection.
+
+```go
+result := lo.TrimRight([]int{0, 1, 2, 0, 3, 0}, []int{0, 3})
+// []int{0, 1, 2}
+
+result := lo.TrimRight([]string{"hello", "world", "  "}, []string{" ", ""})
+// []string{"hello", "world", ""}
+```
+
+[[play](https://go.dev/play/p/MRpAfR6sf0g)]
+
+### TrimSuffix
+
+Removes all the trailing suffix from the collection.
+
+```go
+result := lo.TrimSuffix([]int{1, 2, 3, 1, 2, 4, 2, 4, 2, 4}, []int{2, 4})
+// []int{1, 2, 3, 1}
+
+result := lo.TrimSuffix([]string{"hello", "world", "hello", "test"}, []string{"test"})
+// []string{"hello", "world", "hello"}
+```
+
+[[play](https://go.dev/play/p/IjEUrV0iofq)]
+
 ### Keys
 
-Creates an array of the map keys.
+Creates a slice of the map keys.
+
+Use the UniqKeys variant to deduplicate common keys.
 
 ```go
-keys := lo.Keys[string, int](map[string]int{"foo": 1, "bar": 2})
+keys := lo.Keys(map[string]int{"foo": 1, "bar": 2})
 // []string{"foo", "bar"}
+
+keys := lo.Keys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3})
+// []string{"foo", "bar", "baz"}
+
+keys := lo.Keys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"bar": 3})
+// []string{"foo", "bar", "bar"}
 ```
 
 [[play](https://go.dev/play/p/Uu11fHASqrU)]
 
+### UniqKeys
+
+Creates a slice of unique map keys.
+
+```go
+keys := lo.UniqKeys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3})
+// []string{"foo", "bar", "baz"}
+
+keys := lo.UniqKeys(map[string]int{"foo": 1, "bar": 2}, map[string]int{"bar": 3})
+// []string{"foo", "bar"}
+```
+
+[[play](https://go.dev/play/p/TPKAb6ILdHk)]
+
+### HasKey
+
+Returns whether the given key exists.
+
+```go
+exists := lo.HasKey(map[string]int{"foo": 1, "bar": 2}, "foo")
+// true
+
+exists := lo.HasKey(map[string]int{"foo": 1, "bar": 2}, "baz")
+// false
+```
+
+[[play](https://go.dev/play/p/aVwubIvECqS)]
+
 ### Values
 
-Creates an array of the map values.
+Creates a slice of the map values.
+
+Use the UniqValues variant to deduplicate common values.
 
 ```go
-values := lo.Values[string, int](map[string]int{"foo": 1, "bar": 2})
+values := lo.Values(map[string]int{"foo": 1, "bar": 2})
 // []int{1, 2}
+
+values := lo.Values(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3})
+// []int{1, 2, 3}
+
+values := lo.Values(map[string]int{"foo": 1, "bar": 2}, map[string]int{"bar": 2})
+// []int{1, 2, 2}
 ```
 
 [[play](https://go.dev/play/p/nnRTQkzQfF6)]
 
+### UniqValues
+
+Creates a slice of unique map values.
+
+```go
+values := lo.UniqValues(map[string]int{"foo": 1, "bar": 2})
+// []int{1, 2}
+
+values := lo.UniqValues(map[string]int{"foo": 1, "bar": 2}, map[string]int{"baz": 3})
+// []int{1, 2, 3}
+
+values := lo.UniqValues(map[string]int{"foo": 1, "bar": 2}, map[string]int{"bar": 2})
+// []int{1, 2}
+```
+
+[[play](https://go.dev/play/p/nf6bXMh7rM3)]
+
+### ValueOr
+
+Returns the value of the given key or the fallback value if the key is not present.
+
+```go
+value := lo.ValueOr(map[string]int{"foo": 1, "bar": 2}, "foo", 42)
+// 1
+
+value := lo.ValueOr(map[string]int{"foo": 1, "bar": 2}, "baz", 42)
+// 42
+```
+
+[[play](https://go.dev/play/p/bAq9mHErB4V)]
+
 ### PickBy
 
 Returns same map type filtered by given predicate.
 
 ```go
-m := lo.PickBy[string, int](map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(key string, value int) bool {
+m := lo.PickBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(key string, value int) bool {
     return value%2 == 1
 })
 // map[string]int{"foo": 1, "baz": 3}
 ```
 
+```go
+// Use PickByErr when the predicate can return an error
+m, err := lo.PickByErr(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(key string, value int) (bool, error) {
+    if key == "bar" {
+        return false, fmt.Errorf("bar not allowed")
+    }
+    return value%2 == 1, nil
+})
+// map[string]int(nil), error("bar not allowed")
+```
+
 [[play](https://go.dev/play/p/kdg8GR_QMmf)]
 
 ### PickByKeys
@@ -858,7 +1741,7 @@ m := lo.PickBy[string, int](map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(k
 Returns same map type filtered by given keys.
 
 ```go
-m := lo.PickByKeys[string, int](map[string]int{"foo": 1, "bar": 2, "baz": 3}, []string{"foo", "baz"})
+m := lo.PickByKeys(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []string{"foo", "baz"})
 // map[string]int{"foo": 1, "baz": 3}
 ```
 
@@ -869,7 +1752,7 @@ m := lo.PickByKeys[string, int](map[string]int{"foo": 1, "bar": 2, "baz": 3}, []
 Returns same map type filtered by given values.
 
 ```go
-m := lo.PickByValues[string, int](map[string]int{"foo": 1, "bar": 2, "baz": 3}, []int{1, 3})
+m := lo.PickByValues(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []int{1, 3})
 // map[string]int{"foo": 1, "baz": 3}
 ```
 
@@ -880,12 +1763,23 @@ m := lo.PickByValues[string, int](map[string]int{"foo": 1, "bar": 2, "baz": 3},
 Returns same map type filtered by given predicate.
 
 ```go
-m := lo.OmitBy[string, int](map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(key string, value int) bool {
+m := lo.OmitBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(key string, value int) bool {
     return value%2 == 1
 })
 // map[string]int{"bar": 2}
 ```
 
+```go
+// Use OmitByErr when the predicate can return an error
+m, err := lo.OmitByErr(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(key string, value int) (bool, error) {
+    if key == "bar" {
+        return false, fmt.Errorf("bar not allowed")
+    }
+    return value%2 == 1, nil
+})
+// map[string]int(nil), error("bar not allowed")
+```
+
 [[play](https://go.dev/play/p/EtBsR43bdsd)]
 
 ### OmitByKeys
@@ -893,7 +1787,7 @@ m := lo.OmitBy[string, int](map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(k
 Returns same map type filtered by given keys.
 
 ```go
-m := lo.OmitByKeys[string, int](map[string]int{"foo": 1, "bar": 2, "baz": 3}, []string{"foo", "baz"})
+m := lo.OmitByKeys(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []string{"foo", "baz"})
 // map[string]int{"bar": 2}
 ```
 
@@ -904,7 +1798,7 @@ m := lo.OmitByKeys[string, int](map[string]int{"foo": 1, "bar": 2, "baz": 3}, []
 Returns same map type filtered by given values.
 
 ```go
-m := lo.OmitByValues[string, int](map[string]int{"foo": 1, "bar": 2, "baz": 3}, []int{1, 3})
+m := lo.OmitByValues(map[string]int{"foo": 1, "bar": 2, "baz": 3}, []int{1, 3})
 // map[string]int{"bar": 2}
 ```
 
@@ -912,10 +1806,10 @@ m := lo.OmitByValues[string, int](map[string]int{"foo": 1, "bar": 2, "baz": 3},
 
 ### Entries (alias: ToPairs)
 
-Transforms a map into array of key/value pairs.
+Transforms a map into a slice of key/value pairs.
 
 ```go
-entries := lo.Entries[string, int](map[string]int{"foo": 1, "bar": 2})
+entries := lo.Entries(map[string]int{"foo": 1, "bar": 2})
 // []lo.Entry[string, int]{
 //     {
 //         Key: "foo",
@@ -928,14 +1822,14 @@ entries := lo.Entries[string, int](map[string]int{"foo": 1, "bar": 2})
 // }
 ```
 
-[[play](https://go.dev/play/p/3Dhgx46gawJ)]
+[[play](https://go.dev/play/p/_t4Xe34-Nl5)]
 
 ### FromEntries (alias: FromPairs)
 
-Transforms an array of key/value pairs into a map.
+Transforms a slice of key/value pairs into a map.
 
 ```go
-m := lo.FromEntries[string, int]([]lo.Entry[string, int]{
+m := lo.FromEntries([]lo.Entry[string, int]{
     {
         Key: "foo",
         Value: 1,
@@ -955,10 +1849,10 @@ m := lo.FromEntries[string, int]([]lo.Entry[string, int]{
 Creates a map composed of the inverted keys and values. If map contains duplicate values, subsequent values overwrite property assignments of previous values.
 
 ```go
-m1 := lo.Invert[string, int](map[string]int{"a": 1, "b": 2})
+m1 := lo.Invert(map[string]int{"a": 1, "b": 2})
 // map[int]string{1: "a", 2: "b"}
 
-m2 := lo.Invert[string, int](map[string]int{"a": 1, "b": 2, "c": 1})
+m2 := lo.Invert(map[string]int{"a": 1, "b": 2, "c": 1})
 // map[int]string{1: "c", 2: "b"}
 ```
 
@@ -969,7 +1863,7 @@ m2 := lo.Invert[string, int](map[string]int{"a": 1, "b": 2, "c": 1})
 Merges multiple maps from left to right.
 
 ```go
-mergedMaps := lo.Assign[string, int](
+mergedMaps := lo.Assign(
     map[string]int{"a": 1, "b": 2},
     map[string]int{"b": 3, "c": 4},
 )
@@ -978,37 +1872,109 @@ mergedMaps := lo.Assign[string, int](
 
 [[play](https://go.dev/play/p/VhwfJOyxf5o)]
 
+### ChunkEntries
+
+Splits a map into a slice of elements in groups of length equal to its size. If the map cannot be split evenly, the final chunk will contain the remaining elements.
+
+```go
+maps := lo.ChunkEntries(
+    map[string]int{
+        "a": 1,
+        "b": 2,
+        "c": 3,
+        "d": 4,
+        "e": 5,
+    },
+    3,
+)
+// []map[string]int{
+//    {"a": 1, "b": 2, "c": 3},
+//    {"d": 4, "e": 5},
+// }
+```
+[[play](https://go.dev/play/p/X_YQL6mmoD-)]
+
 ### MapKeys
 
-Manipulates a map keys and transforms it to a map of another type.
+Manipulates map keys and transforms it to a map of another type.
 
 ```go
-m2 := lo.MapKeys[int, int, string](map[int]int{1: 1, 2: 2, 3: 3, 4: 4}, func(_ int, v int) string {
+m2 := lo.MapKeys(map[int]int{1: 1, 2: 2, 3: 3, 4: 4}, func(_ int, v int) string {
     return strconv.FormatInt(int64(v), 10)
 })
 // map[string]int{"1": 1, "2": 2, "3": 3, "4": 4}
 ```
 
+```go
+// Use MapKeysErr when the iteratee can return an error
+m2, err := lo.MapKeysErr(map[int]int{1: 1, 2: 2, 3: 3}, func(_ int, v int) (string, error) {
+    if v == 2 {
+        return "", fmt.Errorf("even number not allowed")
+    }
+    return strconv.FormatInt(int64(v), 10), nil
+})
+// map[string]int(nil), error("even number not allowed")
+```
+
 [[play](https://go.dev/play/p/9_4WPIqOetJ)]
 
 ### MapValues
 
-Manipulates a map values and transforms it to a map of another type.
+Manipulates map values and transforms it to a map of another type.
 
 ```go
 m1 := map[int]int64{1: 1, 2: 2, 3: 3}
 
-m2 := lo.MapValues[int, int64, string](m1, func(x int64, _ int) string {
-	return strconv.FormatInt(x, 10)
+m2 := lo.MapValues(m1, func(x int64, _ int) string {
+    return strconv.FormatInt(x, 10)
 })
 // map[int]string{1: "1", 2: "2", 3: "3"}
 ```
 
+```go
+// Use MapValuesErr when the iteratee can return an error
+m1 := map[int]int64{1: 1, 2: 2, 3: 3}
+m2, err := lo.MapValuesErr(m1, func(x int64, _ int) (string, error) {
+    if x == 2 {
+        return "", fmt.Errorf("even number not allowed")
+    }
+    return strconv.FormatInt(x, 10), nil
+})
+// map[int]string(nil), error("even number not allowed")
+```
+
 [[play](https://go.dev/play/p/T_8xAfvcf0W)]
 
+### MapEntries
+
+Manipulates map entries and transforms it to a map of another type.
+
+```go
+in := map[string]int{"foo": 1, "bar": 2}
+
+out := lo.MapEntries(in, func(k string, v int) (int, string) {
+    return v,k
+})
+// map[int]string{1: "foo", 2: "bar"}
+```
+
+```go
+// Use MapEntriesErr when the iteratee can return an error
+in := map[string]int{"foo": 1, "bar": 2, "baz": 3}
+out, err := lo.MapEntriesErr(in, func(k string, v int) (int, string, error) {
+    if k == "bar" {
+        return 0, "", fmt.Errorf("bar not allowed")
+    }
+    return v, k, nil
+})
+// map[int]string(nil), error("bar not allowed")
+```
+
+[[play](https://go.dev/play/p/VuvNQzxKimT)]
+
 ### MapToSlice
 
-Transforms a map into a slice based on specific iteratee.
+Transforms a map into a slice based on specified iteratee.
 
 ```go
 m := map[int]int64{1: 4, 2: 5, 3: 6}
@@ -1019,35 +1985,126 @@ s := lo.MapToSlice(m, func(k int, v int64) string {
 // []string{"1_4", "2_5", "3_6"}
 ```
 
+```go
+// Use MapToSliceErr when the iteratee can return an error
+m := map[int]int64{1: 4, 2: 5, 3: 6}
+s, err := lo.MapToSliceErr(m, func(k int, v int64) (string, error) {
+    if k == 2 {
+        return "", fmt.Errorf("key 2 not allowed")
+    }
+    return fmt.Sprintf("%d_%d", k, v), nil
+})
+// []string(nil), error("key 2 not allowed")
+```
+
 [[play](https://go.dev/play/p/ZuiCZpDt6LD)]
 
+### FilterMapToSlice
+
+Transforms a map into a slice based on specified iteratee. The iteratee returns a value and a boolean. If the boolean is true, the value is added to the result slice.
+
+If the boolean is false, the value is not added to the result slice. The order of the keys in the input map is not specified and the order of the keys in the output slice is not guaranteed.
+
+```go
+kv := map[int]int64{1: 1, 2: 2, 3: 3, 4: 4}
+
+result := lo.FilterMapToSlice(kv, func(k int, v int64) (string, bool) {
+    return fmt.Sprintf("%d_%d", k, v), k%2 == 0
+})
+// []{"2_2", "4_4"}
+```
+
+```go
+kv := map[int]int64{1: 1, 2: 2, 3: 3, 4: 4}
+
+result, err := lo.FilterMapToSliceErr(kv, func(k int, v int64) (string, bool, error) {
+    if k == 3 {
+        return "", false, fmt.Errorf("key 3 not allowed")
+    }
+    return fmt.Sprintf("%d_%d", k, v), k%2 == 0, nil
+})
+// []string(nil), error("key 3 not allowed")
+```
+
+### FilterKeys
+
+Transforms a map into a slice based on predicate returns true for specific elements. It is a mix of `lo.Filter()` and `lo.Keys()`.
+
+```go
+kv := map[int]string{1: "foo", 2: "bar", 3: "baz"}
+
+result := FilterKeys(kv, func(k int, v string) bool {
+    return v == "foo"
+})
+// [1]
+```
+
+```go
+// Use FilterKeysErr when the predicate can return an error
+result, err := lo.FilterKeysErr(map[int]string{1: "foo", 2: "bar", 3: "baz"}, func(k int, v string) (bool, error) {
+    if k == 3 {
+        return false, fmt.Errorf("key 3 not allowed")
+    }
+    return v == "foo", nil
+})
+// []int(nil), error("key 3 not allowed")
+```
+
+[[play](https://go.dev/play/p/OFlKXlPrBAe)]
+
+### FilterValues
+
+Transforms a map into a slice based on predicate returns true for specific elements. It is a mix of `lo.Filter()` and `lo.Values()`.
+
+```go
+kv := map[int]string{1: "foo", 2: "bar", 3: "baz"}
+
+result := FilterValues(kv, func(k int, v string) bool {
+    return v == "foo"
+})
+// ["foo"]
+```
+
+```go
+// Use FilterValuesErr when the predicate can return an error
+result, err := lo.FilterValuesErr(map[int]string{1: "foo", 2: "bar", 3: "baz"}, func(k int, v string) (bool, error) {
+    if k == 3 {
+        return false, fmt.Errorf("key 3 not allowed")
+    }
+    return v == "foo", nil
+})
+// []string(nil), error("key 3 not allowed")
+```
+
+[[play](https://go.dev/play/p/YVD5r_h-LX-)]
+
 ### Range / RangeFrom / RangeWithSteps
 
-Creates an array of numbers (positive and/or negative) progressing from start up to, but not including end.
+Creates a slice of numbers (positive and/or negative) progressing from start up to, but not including end.
 
 ```go
-result := Range(4)
+result := lo.Range(4)
 // [0, 1, 2, 3]
 
-result := Range(-4)
+result := lo.Range(-4)
 // [0, -1, -2, -3]
 
-result := RangeFrom(1, 5)
+result := lo.RangeFrom(1, 5)
 // [1, 2, 3, 4, 5]
 
-result := RangeFrom[float64](1.0, 5)
+result := lo.RangeFrom[float64](1.0, 5)
 // [1.0, 2.0, 3.0, 4.0, 5.0]
 
-result := RangeWithSteps(0, 20, 5)
+result := lo.RangeWithSteps(0, 20, 5)
 // [0, 5, 10, 15]
 
-result := RangeWithSteps[float32](-1.0, -4.0, -1.0)
+result := lo.RangeWithSteps[float32](-1.0, -4.0, -1.0)
 // [-1.0, -2.0, -3.0]
 
-result := RangeWithSteps(1, 4, -1)
+result := lo.RangeWithSteps(1, 4, -1)
 // []
 
-result := Range(0)
+result := lo.Range(0)
 // []
 ```
 
@@ -1070,9 +2127,24 @@ r3 := lo.Clamp(42, -10, 10)
 
 [[play](https://go.dev/play/p/RU4lJNC2hlI)]
 
+### Sum
+
+Sums the values in a collection.
+
+If collection is empty 0 is returned.
+
+```go
+list := []int{1, 2, 3, 4, 5}
+sum := lo.Sum(list)
+// 15
+```
+
+[[play](https://go.dev/play/p/upfeJVqs4Bt)]
+
 ### SumBy
 
 Summarizes the values in a collection using the given return value from the iteration function.
+
 If collection is empty 0 is returned.
 
 ```go
@@ -1083,11 +2155,147 @@ sum := lo.SumBy(strings, func(item string) int {
 // 6
 ```
 
-[[play](https://go.dev/play/p/Dz_a_7jN_ca)]
-
-### Substring
+With error handling:
 
-Return part of a string.
+```go
+strings := []string{"foo", "bar", "baz"}
+sum, err := lo.SumByErr(strings, func(item string) (int, error) {
+    if item == "bar" {
+        return 0, fmt.Errorf("invalid item: %s", item)
+    }
+    return len(item), nil
+})
+// sum: 3, err: invalid item: bar
+```
+
+### Product
+
+Calculates the product of the values in a collection.
+
+If collection is empty 0 is returned.
+
+```go
+list := []int{1, 2, 3, 4, 5}
+product := lo.Product(list)
+// 120
+```
+
+[[play](https://go.dev/play/p/2_kjM_smtAH)]
+
+### ProductBy
+
+Calculates the product of the values in a collection using the given return value from the iteration function.
+
+If collection is empty 0 is returned.
+
+```go
+strings := []string{"foo", "bar"}
+product := lo.ProductBy(strings, func(item string) int {
+    return len(item)
+})
+// 9
+```
+
+```go
+// Use ProductByErr when the transform function can return an error
+strings := []string{"foo", "bar", "baz"}
+product, err := lo.ProductByErr(strings, func(item string) (int, error) {
+    if item == "bar" {
+        return 0, fmt.Errorf("bar is not allowed")
+    }
+    return len(item), nil
+})
+// 3, error("bar is not allowed")
+```
+
+[[play](https://go.dev/play/p/wadzrWr9Aer)]
+
+### Mean
+
+Calculates the mean of a collection of numbers.
+
+If collection is empty 0 is returned.
+
+```go
+mean := lo.Mean([]int{2, 3, 4, 5})
+// 3
+
+mean := lo.Mean([]float64{2, 3, 4, 5})
+// 3.5
+
+mean := lo.Mean([]float64{})
+// 0
+```
+
+### MeanBy
+
+Calculates the mean of a collection of numbers using the given return value from the iteration function.
+
+If collection is empty 0 is returned.
+
+```go
+list := []string{"aa", "bbb", "cccc", "ddddd"}
+mapper := func(item string) float64 {
+    return float64(len(item))
+}
+
+mean := lo.MeanBy(list, mapper)
+// 3.5
+
+mean := lo.MeanBy([]float64{}, mapper)
+// 0
+```
+
+```go
+// Use MeanByErr when the transform function can return an error
+list := []string{"aa", "bbb", "cccc", "ddddd"}
+mean, err := lo.MeanByErr(list, func(item string) (float64, error) {
+    if item == "cccc" {
+        return 0, fmt.Errorf("cccc is not allowed")
+    }
+    return float64(len(item)), nil
+})
+// 0, error("cccc is not allowed")
+```
+
+[[play](https://go.dev/play/p/j7TsVwBOZ7P)]
+
+### Mode
+
+Calculates the mode (most frequent value) of a collection of numbers.
+
+If multiple values have the same highest frequency, then multiple values are returned.
+
+If the collection is empty, the zero value of `T[]` is returned.
+
+```go
+mode := lo.Mode([]int{2, 2, 3, 4})
+// [2]
+
+mode := lo.Mode([]float64{2, 2, 3, 3})
+// [2, 3]
+
+mode := lo.Mode([]float64{})
+// []
+
+mode := lo.Mode([]int{1, 2, 3, 4, 5, 6, 7, 8, 9})
+// [1, 2, 3, 4, 5, 6, 7, 8, 9]
+```
+
+### RandomString
+
+Returns a random string of the specified length and made of the specified charset.
+
+```go
+str := lo.RandomString(5, lo.LettersCharset)
+// example: "eIGbt"
+```
+
+[[play](https://go.dev/play/p/rRseOQVVum4)]
+
+### Substring
+
+Return part of a string.
 
 ```go
 sub := lo.Substring("hello", 2, 3)
@@ -1104,7 +2312,7 @@ sub := lo.Substring("hello", -2, math.MaxUint)
 
 ### ChunkString
 
-Returns an array of strings split into groups the length of size. If array can't be split evenly, the final chunk will be the remaining elements.
+Returns a slice of strings split into groups of length size. If the string can't be split evenly, the final chunk will be the remaining characters.
 
 ```go
 lo.ChunkString("123456", 2)
@@ -1120,6 +2328,8 @@ lo.ChunkString("1", 2)
 // []string{"1"}
 ```
 
+Note: `lo.ChunkString` and `lo.Chunk` functions behave inconsistently for empty input: `lo.ChunkString("", n)` returns `[""]` instead of `[]`. See [#788](https://github.com/samber/lo/issues/788).
+
 [[play](https://go.dev/play/p/__FLTuJVz54)]
 
 ### RuneLength
@@ -1136,6 +2346,95 @@ sub := len("hellô")
 
 [[play](https://go.dev/play/p/tuhgW_lWY8l)]
 
+### PascalCase
+
+Converts string to pascal case.
+
+```go
+str := lo.PascalCase("hello_world")
+// HelloWorld
+```
+
+[[play](https://go.dev/play/p/Dy_V_6DUYhe)]
+
+### CamelCase
+
+Converts string to camel case.
+
+```go
+str := lo.CamelCase("hello_world")
+// helloWorld
+```
+
+[[play](https://go.dev/play/p/Go6aKwUiq59)]
+
+### KebabCase
+
+Converts string to kebab case.
+
+```go
+str := lo.KebabCase("helloWorld")
+// hello-world
+```
+
+[[play](https://go.dev/play/p/96gT_WZnTVP)]
+
+### SnakeCase
+
+Converts string to snake case.
+
+```go
+str := lo.SnakeCase("HelloWorld")
+// hello_world
+```
+
+[[play](https://go.dev/play/p/ziB0V89IeVH)]
+
+### Words
+
+Splits string into a slice of its words.
+
+```go
+str := lo.Words("helloWorld")
+// []string{"hello", "world"}
+```
+
+[[play](https://go.dev/play/p/-f3VIQqiaVw)]
+
+### Capitalize
+
+Converts the first character of string to upper case and the remaining to lower case.
+
+```go
+str := lo.Capitalize("heLLO")
+// Hello
+```
+
+[[play](https://go.dev/play/p/uLTZZQXqnsa)]
+
+### Ellipsis
+
+Trims and truncates a string to a specified length in runes (Unicode code points) and appends an ellipsis if truncated. Multi-byte characters such as emoji or CJK ideographs are never split in the middle.
+
+```go
+str := lo.Ellipsis("  Lorem Ipsum  ", 5)
+// Lo...
+
+str := lo.Ellipsis("Lorem Ipsum", 100)
+// Lorem Ipsum
+
+str := lo.Ellipsis("Lorem Ipsum", 3)
+// ...
+
+str := lo.Ellipsis("hello 世界! 你好", 8)
+// hello...
+
+str := lo.Ellipsis("🏠🐶🐱🌟", 4)
+// 🏠🐶🐱🌟
+```
+
+[[play](https://go.dev/play/p/qE93rgqe1TW)]
+
 ### T2 -> T9
 
 Creates a tuple from a list of values.
@@ -1153,10 +2452,18 @@ tuple2 := lo.T2(example())
 
 ### Unpack2 -> Unpack9
 
-Returns values contained in tuple.
+Returns values contained in a tuple.
+
+```go
+r1, r2 := lo.Unpack2(lo.Tuple2[string, int]{"a", 1})
+// "a", 1
+```
+
+Unpack is also available as a method of TupleX.
 
 ```go
-r1, r2 := lo.Unpack2[string, int](lo.Tuple2[string, int]{"a", 1})
+tuple2 := lo.T2("a", 1)
+a, b := tuple2.Unpack()
 // "a", 1
 ```
 
@@ -1164,29 +2471,160 @@ r1, r2 := lo.Unpack2[string, int](lo.Tuple2[string, int]{"a", 1})
 
 ### Zip2 -> Zip9
 
-Zip creates a slice of grouped elements, the first of which contains the first elements of the given arrays, the second of which contains the second elements of the given arrays, and so on.
+Zip creates a slice of grouped elements, the first of which contains the first elements of the given slices, the second of which contains the second elements of the given slices, and so on.
 
-When collections have different size, the Tuple attributes are filled with zero value.
+When collections are different sizes, the Tuple attributes are filled with zero value.
 
 ```go
-tuples := lo.Zip2[string, int]([]string{"a", "b"}, []int{1, 2})
+tuples := lo.Zip2([]string{"a", "b"}, []int{1, 2})
 // []Tuple2[string, int]{{A: "a", B: 1}, {A: "b", B: 2}}
 ```
 
 [[play](https://go.dev/play/p/jujaA6GaJTp)]
 
+### ZipBy2 -> ZipBy9
+
+ZipBy creates a slice of transformed elements, the first of which contains the first elements of the given slices, the second of which contains the second elements of the given slices, and so on.
+
+When collections are different sizes, the Tuple attributes are filled with zero value.
+
+```go
+items := lo.ZipBy2([]string{"a", "b"}, []int{1, 2}, func(a string, b int) string {
+    return fmt.Sprintf("%s-%d", a, b)
+})
+// []string{"a-1", "b-2"}
+```
+
+With error handling:
+
+```go
+items, err := lo.ZipByErr2([]string{"a", "b"}, []int{1, 2}, func(a string, b int) (string, error) {
+    if b == 2 {
+        return "", fmt.Errorf("number 2 is not allowed")
+    }
+    return fmt.Sprintf("%s-%d", a, b), nil
+})
+// []string(nil), error("number 2 is not allowed")
+```
+
 ### Unzip2 -> Unzip9
 
-Unzip accepts an array of grouped elements and creates an array regrouping the elements to their pre-zip configuration.
+Unzip accepts a slice of grouped elements and creates a slice regrouping the elements to their pre-zip configuration.
 
 ```go
-a, b := lo.Unzip2[string, int]([]Tuple2[string, int]{{A: "a", B: 1}, {A: "b", B: 2}})
+a, b := lo.Unzip2([]Tuple2[string, int]{{A: "a", B: 1}, {A: "b", B: 2}})
 // []string{"a", "b"}
 // []int{1, 2}
 ```
 
 [[play](https://go.dev/play/p/ciHugugvaAW)]
 
+### UnzipBy2 -> UnzipBy9
+
+UnzipBy2 iterates over a collection and creates a slice regrouping the elements to their pre-zip configuration.
+
+```go
+a, b := lo.UnzipBy2([]string{"hello", "john", "doe"}, func(str string) (string, int) {
+    return str, len(str)
+})
+// []string{"hello", "john", "doe"}
+// []int{5, 4, 3}
+```
+
+```go
+a, b, err := lo.UnzipByErr2([]string{"hello", "error", "world"}, func(str string) (string, int, error) {
+    if str == "error" {
+        return "", 0, fmt.Errorf("error string not allowed")
+    }
+    return str, len(str), nil
+})
+// []string{}
+// []int{}
+// error string not allowed
+```
+
+### CrossJoin2 -> CrossJoin9
+
+Combines every item from one list with every item from others. It is the cartesian product of lists received as arguments. Returns an empty list if a list is empty.
+
+```go
+result := lo.CrossJoin2([]string{"hello", "john", "doe"}, []int{1, 2})
+// lo.Tuple2{"hello", 1}
+// lo.Tuple2{"hello", 2}
+// lo.Tuple2{"john", 1}
+// lo.Tuple2{"john", 2}
+// lo.Tuple2{"doe", 1}
+// lo.Tuple2{"doe", 2}
+```
+
+### CrossJoinBy2 -> CrossJoinBy9
+
+Combines every item from one list with every item from others. It is the cartesian product of lists received as arguments. The transform function is used to create the output values. Returns an empty list if a list is empty.
+
+```go
+result := lo.CrossJoinBy2([]string{"hello", "john", "doe"}, []int{1, 2}, func(a A, b B) string {
+    return fmt.Sprintf("%s - %d", a, b)
+})
+// "hello - 1"
+// "hello - 2"
+// "john - 1"
+// "john - 2"
+// "doe - 1"
+// "doe - 2"
+```
+
+With error handling:
+
+```go
+result, err := lo.CrossJoinByErr2([]string{"hello", "john"}, []int{1, 2}, func(a string, b int) (string, error) {
+    if a == "john" {
+        return "", fmt.Errorf("john not allowed")
+    }
+    return fmt.Sprintf("%s - %d", a, b), nil
+})
+// []string(nil), error("john not allowed")
+```
+
+### Duration
+
+Returns the time taken to execute a function.
+
+```go
+duration := lo.Duration(func() {
+    // very long job
+})
+// 3s
+```
+
+[[play](https://go.dev/play/p/HQfbBbAXaFP)]
+
+### Duration0 -> Duration10
+
+Returns the time taken to execute a function.
+
+```go
+duration := lo.Duration0(func() {
+    // very long job
+})
+// 3s
+
+err, duration := lo.Duration1(func() error {
+    // very long job
+    return errors.New("an error")
+})
+// an error
+// 3s
+
+str, nbr, err, duration := lo.Duration3(func() (string, int, error) {
+    // very long job
+    return "hello", 42, nil
+})
+// hello
+// 42
+// nil
+// 3s
+```
+
 ### ChannelDispatcher
 
 Distributes messages from input channels into N child channels. Close events are propagated to children.
@@ -1207,6 +2645,7 @@ consumer := func(c <-chan int) {
         msg, ok := <-c
         if !ok {
             println("closed")
+
             break
         }
 
@@ -1219,6 +2658,8 @@ for i := range children {
 }
 ```
 
+[[play](https://go.dev/play/p/UZGu2wVg3J2)]
+
 Many distributions strategies are available:
 
 - [lo.DispatchingStrategyRoundRobin](./channel.go): Distributes messages in a rotating sequential manner.
@@ -1226,7 +2667,7 @@ Many distributions strategies are available:
 - [lo.DispatchingStrategyWeightedRandom](./channel.go): Distributes messages in a weighted manner.
 - [lo.DispatchingStrategyFirst](./channel.go): Distributes messages in the first non-full channel.
 - [lo.DispatchingStrategyLeast](./channel.go): Distributes messages in the emptiest channel.
-- [lo.DispatchingStrategyMost](./channel.go): Distributes to the fulliest channel.
+- [lo.DispatchingStrategyMost](./channel.go): Distributes to the fullest channel.
 
 Some strategies bring fallback, in order to favor non-blocking behaviors. See implementations.
 
@@ -1244,14 +2685,14 @@ type Message struct {
 }
 
 func hash(id uuid.UUID) int {
-	h := fnv.New32a()
-	h.Write([]byte(id.String()))
-	return int(h.Sum32())
+    h := fnv.New32a()
+    h.Write([]byte(id.String()))
+    return int(h.Sum32())
 }
 
 // Routes messages per TenantID.
-customStrategy := func(message pubsub.AMQPSubMessage, messageIndex uint64, channels []<-chan pubsub.AMQPSubMessage) int {
-    destination := hash(message.TenantID) % len(channels)
+customStrategy := func(message string, messageIndex uint64, channels []<-chan string) int {
+    destination := hash(message) % len(channels)
 
     // check if channel is full
     if len(channels[destination]) < cap(channels[destination]) {
@@ -1268,17 +2709,31 @@ children := lo.ChannelDispatcher(ch, 5, 10, customStrategy)
 
 ### SliceToChannel
 
-Returns a read-only channels of collection elements. Channel is closed after last element. Channel capacity can be customized.
+Returns a read-only channel of collection elements. Channel is closed after last element. Channel capacity can be customized.
 
 ```go
 list := []int{1, 2, 3, 4, 5}
 
 for v := range lo.SliceToChannel(2, list) {
-    println(v)		
+    println(v)
 }
 // prints 1, then 2, then 3, then 4, then 5
 ```
 
+[[play](https://go.dev/play/p/lIbSY3QmiEg)]
+
+### ChannelToSlice
+
+Returns a slice built from channel items. Blocks until channel closes.
+
+```go
+list := []int{1, 2, 3, 4, 5}
+ch := lo.SliceToChannel(2, list)
+
+items := ChannelToSlice(ch)
+// []int{1, 2, 3, 4, 5}
+```
+
 ### Generator
 
 Implements the generator design pattern. Channel is closed after last element. Channel capacity can be customized.
@@ -1296,16 +2751,16 @@ for v := range lo.Generator(2, generator) {
 // prints 1, then 2, then 3
 ```
 
-### Batch
+### Buffer
 
 Creates a slice of n elements from a channel. Returns the slice, the slice length, the read time and the channel status (opened/closed).
 
 ```go
 ch := lo.SliceToChannel(2, []int{1, 2, 3, 4, 5})
 
-items1, length1, duration1, ok1 := lo.Batch(ch, 3)
+items1, length1, duration1, ok1 := lo.Buffer(ch, 3)
 // []int{1, 2, 3}, 3, 0s, true
-items2, length2, duration2, ok2 := lo.Batch(ch, 3)
+items2, length2, duration2, ok2 := lo.Buffer(ch, 3)
 // []int{4, 5}, 2, 0s, false
 ```
 
@@ -1316,7 +2771,7 @@ ch := readFromQueue()
 
 for {
     // read 1k items
-    items, length, _, ok := lo.Batch(ch, 1000)
+    items, length, _, ok := lo.Buffer(ch, 1000)
 
     // do batching stuff
 
@@ -1326,7 +2781,33 @@ for {
 }
 ```
 
-### BatchWithTimeout
+### BufferWithContext
+
+Creates a slice of n elements from a channel, with timeout. Returns the slice, the slice length, the read time and the channel status (opened/closed).
+
+```go
+ctx, cancel := context.WithCancel(context.TODO())
+go func() {
+    ch <- 0
+    time.Sleep(10*time.Millisecond)
+    ch <- 1
+    time.Sleep(10*time.Millisecond)
+    ch <- 2
+    time.Sleep(10*time.Millisecond)
+    ch <- 3
+    time.Sleep(10*time.Millisecond)
+    ch <- 4
+    time.Sleep(10*time.Millisecond)
+    cancel()
+}()
+
+items1, length1, duration1, ok1 := lo.BufferWithContext(ctx, ch, 3)
+// []int{0, 1, 2}, 3, 20ms, true
+items2, length2, duration2, ok2 := lo.BufferWithContext(ctx, ch, 3)
+// []int{3, 4}, 2, 30ms, false
+```
+
+### BufferWithTimeout
 
 Creates a slice of n elements from a channel, with timeout. Returns the slice, the slice length, the read time and the channel status (opened/closed).
 
@@ -1340,11 +2821,11 @@ generator := func(yield func(int)) {
 
 ch := lo.Generator(0, generator)
 
-items1, length1, duration1, ok1 := lo.BatchWithTimeout(ch, 3, 100*time.Millisecond)
+items1, length1, duration1, ok1 := lo.BufferWithTimeout(ch, 3, 100*time.Millisecond)
 // []int{1, 2}, 2, 100ms, true
-items2, length2, duration2, ok2 := lo.BatchWithTimeout(ch, 3, 100*time.Millisecond)
+items2, length2, duration2, ok2 := lo.BufferWithTimeout(ch, 3, 100*time.Millisecond)
 // []int{3, 4, 5}, 3, 75ms, true
-items3, length3, duration2, ok3 := lo.BatchWithTimeout(ch, 3, 100*time.Millisecond)
+items3, length3, duration2, ok3 := lo.BufferWithTimeout(ch, 3, 100*time.Millisecond)
 // []int{}, 0, 10ms, false
 ```
 
@@ -1356,7 +2837,7 @@ ch := readFromQueue()
 for {
     // read 1k items
     // wait up to 1 second
-    items, length, _, ok := lo.BatchWithTimeout(ch, 1000, 1*time.Second)
+    items, length, _, ok := lo.BufferWithTimeout(ch, 1000, 1*time.Second)
 
     // do batching stuff
 
@@ -1373,13 +2854,13 @@ ch := readFromQueue()
 
 // 5 workers
 // prefetch 1k messages per worker
-children := lo.ChannelDispatcher(ch, 5, 1000, DispatchingStrategyFirst[int])
+children := lo.ChannelDispatcher(ch, 5, 1000, lo.DispatchingStrategyFirst[int])
 
 consumer := func(c <-chan int) {
     for {
         // read 1k items
         // wait up to 1 second
-        items, length, _, ok := lo.BatchWithTimeout(ch, 1000, 1*time.Second)
+        items, length, _, ok := lo.BufferWithTimeout(ch, 1000, 1*time.Second)
 
         // do batching stuff
 
@@ -1394,21 +2875,47 @@ for i := range children {
 }
 ```
 
+### FanIn
+
+Merge messages from multiple input channels into a single buffered channel. Output messages have no priority. When all upstream channels reach EOF, downstream channel closes.
+
+```go
+stream1 := make(chan int, 42)
+stream2 := make(chan int, 42)
+stream3 := make(chan int, 42)
+
+all := lo.FanIn(100, stream1, stream2, stream3)
+// <-chan int
+```
+
+### FanOut
+
+Broadcasts all the upstream messages to multiple downstream channels. When upstream channel reaches EOF, downstream channels close. If any downstream channels is full, broadcasting is paused.
+
+```go
+stream := make(chan int, 42)
+
+all := lo.FanOut(5, 100, stream)
+// [5]<-chan int
+```
+
 ### Contains
 
 Returns true if an element is present in a collection.
 
 ```go
-present := lo.Contains[int]([]int{0, 1, 2, 3, 4, 5}, 5)
+present := lo.Contains([]int{0, 1, 2, 3, 4, 5}, 5)
 // true
 ```
 
+[[play](https://go.dev/play/p/W1EvyqY6t9j)]
+
 ### ContainsBy
 
 Returns true if the predicate function returns `true`.
 
 ```go
-present := lo.ContainsBy[int]([]int{0, 1, 2, 3, 4, 5}, func(x int) bool {
+present := lo.ContainsBy([]int{0, 1, 2, 3, 4, 5}, func(x int) bool {
     return x == 3
 })
 // true
@@ -1416,37 +2923,42 @@ present := lo.ContainsBy[int]([]int{0, 1, 2, 3, 4, 5}, func(x int) bool {
 
 ### Every
 
-Returns true if all elements of a subset are contained into a collection or if the subset is empty.
+Returns true if all elements of a subset are contained in a collection or if the subset is empty.
 
 ```go
-ok := lo.Every[int]([]int{0, 1, 2, 3, 4, 5}, []int{0, 2})
+ok := lo.Every([]int{0, 1, 2, 3, 4, 5}, []int{0, 2})
 // true
 
-ok := lo.Every[int]([]int{0, 1, 2, 3, 4, 5}, []int{0, 6})
+ok := lo.Every([]int{0, 1, 2, 3, 4, 5}, []int{0, 6})
 // false
 ```
 
 ### EveryBy
 
-Returns true if the predicate returns true for all of the elements in the collection or if the collection is empty.
+Returns true if the predicate returns true for all elements in the collection or if the collection is empty.
 
 ```go
-b := EveryBy[int]([]int{1, 2, 3, 4}, func(x int) bool {
+b := EveryBy([]int{1, 2, 3, 4}, func(x int) bool {
     return x < 5
 })
 // true
 ```
 
+[[play](https://go.dev/play/p/dn1-vhHsq9x)]
+
 ### Some
 
-Returns true if at least 1 element of a subset is contained into a collection.
+Returns true if at least 1 element of a subset is contained in a collection.
 If the subset is empty Some returns false.
 
 ```go
-ok := lo.Some[int]([]int{0, 1, 2, 3, 4, 5}, []int{0, 2})
+ok := lo.Some([]int{0, 1, 2, 3, 4, 5}, []int{0, 6})
 // true
+```
+
+[[play](https://go.dev/play/p/Lj4ceFkeT9V)]
 
-ok := lo.Some[int]([]int{0, 1, 2, 3, 4, 5}, []int{-1, 6})
+ok := lo.Some([]int{0, 1, 2, 3, 4, 5}, []int{-1, 6})
 // false
 ```
 
@@ -1456,7 +2968,7 @@ Returns true if the predicate returns true for any of the elements in the collec
 If the collection is empty SomeBy returns false.
 
 ```go
-b := SomeBy[int]([]int{1, 2, 3, 4}, func(x int) bool {
+b := SomeBy([]int{1, 2, 3, 4}, func(x int) bool {
     return x < 3
 })
 // true
@@ -1464,158 +2976,355 @@ b := SomeBy[int]([]int{1, 2, 3, 4}, func(x int) bool {
 
 ### None
 
-Returns true if no element of a subset are contained into a collection or if the subset is empty.
+Returns true if no element of a subset is contained in a collection or if the subset is empty.
 
 ```go
-b := None[int]([]int{0, 1, 2, 3, 4, 5}, []int{0, 2})
+b := None([]int{0, 1, 2, 3, 4, 5}, []int{0, 2})
 // false
-b := None[int]([]int{0, 1, 2, 3, 4, 5}, []int{-1, 6})
+b := None([]int{0, 1, 2, 3, 4, 5}, []int{-1, 6})
 // true
 ```
 
+[[play](https://go.dev/play/p/fye7JsmxzPV)]
+
 ### NoneBy
 
 Returns true if the predicate returns true for none of the elements in the collection or if the collection is empty.
 
 ```go
-b := NoneBy[int]([]int{1, 2, 3, 4}, func(x int) bool {
+b := NoneBy([]int{1, 2, 3, 4}, func(x int) bool {
     return x < 0
 })
 // true
 ```
 
+[[play](https://go.dev/play/p/O64WZ32H58S)]
+
 ### Intersect
 
-Returns the intersection between two collections.
+Returns the intersection between collections.
+
+```go
+result1 := lo.Intersect([]int{0, 1, 2, 3, 4, 5}, []int{0, 2})
+// []int{0, 2}
+
+result2 := lo.Intersect([]int{0, 1, 2, 3, 4, 5}, []int{0, 6})
+// []int{0}
+
+result3 := lo.Intersect([]int{0, 1, 2, 3, 4, 5}, []int{-1, 6})
+// []int{}
+
+result4 := lo.Intersect([]int{0, 3, 5, 7}, []int{3, 5}, []int{0, 1, 2, 0, 3, 0})
+// []int{3}
+```
+
+### IntersectBy
+
+Returns the intersection between two collections using a custom key selector function.
 
 ```go
-result1 := lo.Intersect[int]([]int{0, 1, 2, 3, 4, 5}, []int{0, 2})
+transform := func(v int) string {
+    return strconv.Itoa(v)
+}
+
+result1 := lo.IntersectBy(transform, []int{0, 1, 2, 3, 4, 5}, []int{0, 2})
 // []int{0, 2}
 
-result2 := lo.Intersect[int]([]int{0, 1, 2, 3, 4, 5}, []int{0, 6}
+result2 := lo.IntersectBy(transform, []int{0, 1, 2, 3, 4, 5}, []int{0, 6})
 // []int{0}
 
-result3 := lo.Intersect[int]([]int{0, 1, 2, 3, 4, 5}, []int{-1, 6})
+result3 := lo.IntersectBy(transform, []int{0, 1, 2, 3, 4, 5}, []int{-1, 6})
 // []int{}
+
+result4 := lo.IntersectBy(transform, []int{0, 3, 5, 7}, []int{3, 5}, []int{0, 1, 2, 0, 3, 0})
+// []int{3}
 ```
 
 ### Difference
 
 Returns the difference between two collections.
 
-- The first value is the collection of element absent of list2.
-- The second value is the collection of element absent of list1.
+- The first value is the collection of elements absent from list2.
+- The second value is the collection of elements absent from list1.
 
 ```go
-left, right := lo.Difference[int]([]int{0, 1, 2, 3, 4, 5}, []int{0, 2, 6})
+left, right := lo.Difference([]int{0, 1, 2, 3, 4, 5}, []int{0, 2, 6})
 // []int{1, 3, 4, 5}, []int{6}
 
-left, right := lo.Difference[int]([]int{0, 1, 2, 3, 4, 5}, []int{0, 1, 2, 3, 4, 5})
+left, right := lo.Difference([]int{0, 1, 2, 3, 4, 5}, []int{0, 1, 2, 3, 4, 5})
 // []int{}, []int{}
 ```
 
+[[play](https://go.dev/play/p/pKE-JgzqRpz)]
+
 ### Union
 
-Returns all distinct elements from both collections. Result will not change the order of elements relatively.
+Returns all distinct elements from given collections. Result will not change the order of elements relatively.
 
 ```go
-union := lo.Union[int]([]int{0, 1, 2, 3, 4, 5}, []int{0, 2, 10})
+union := lo.Union([]int{0, 1, 2, 3, 4, 5}, []int{0, 2}, []int{0, 10})
 // []int{0, 1, 2, 3, 4, 5, 10}
 ```
 
 ### Without
 
-Returns slice excluding all given values.
+Returns a slice excluding all given values.
 
 ```go
-subset := lo.Without[int]([]int{0, 2, 10}, 2)
+subset := lo.Without([]int{0, 2, 10}, 2)
 // []int{0, 10}
 
-subset := lo.Without[int]([]int{0, 2, 10}, 0, 1, 2, 3, 4, 5)
+subset := lo.Without([]int{0, 2, 10}, 0, 1, 2, 3, 4, 5)
 // []int{10}
 ```
 
-### WithoutEmpty
+### WithoutBy
 
-Returns slice excluding empty values.
+Filters a slice by excluding elements whose extracted keys match any in the exclude list.
+
+Returns a new slice containing only the elements whose keys are not in the exclude list.
 
 ```go
-subset := lo.WithoutEmpty[int]([]int{0, 2, 10})
-// []int{2, 10}
-```
+type User struct {
+    ID int
+    Name string
+}
 
-### IndexOf
+// original users
+users := []User{
+    {ID: 1, Name: "Alice"},
+    {ID: 2, Name: "Bob"},
+    {ID: 3, Name: "Charlie"},
+}
 
-Returns the index at which the first occurrence of a value is found in an array or return -1 if the value cannot be found.
+// extract function to get the user ID
+getID := func(user User) int {
+    return user.ID
+}
 
-```go
-found := lo.IndexOf[int]([]int{0, 1, 2, 1, 2, 3}, 2)
-// 2
+// exclude users with IDs 2 and 3
+excludedIDs := []int{2, 3}
 
-notFound := lo.IndexOf[int]([]int{0, 1, 2, 1, 2, 3}, 6)
-// -1
+// filtering users
+filteredUsers := lo.WithoutBy(users, getID, excludedIDs...)
+// []User[{ID: 1, Name: "Alice"}]
 ```
 
+```go
+// Use WithoutByErr when the iteratee can return an error
+type struct User {
+    ID int
+    Name string
+}
+
+users := []User{
+    {ID: 1, Name: "Alice"},
+    {ID: 2, Name: "Bob"},
+    {ID: 3, Name: "Charlie"},
+}
+
+getID := func(user User) (int, error) {
+    if user.ID == 2 {
+        return 0, fmt.Errorf("Bob not allowed")
+    }
+    return user.ID, nil
+}
+
+filteredUsers, err := lo.WithoutByErr(users, getID, 2, 3)
+// []User(nil), error("Bob not allowed")
+```
+
+### WithoutEmpty
+
+Returns a slice excluding zero values.
+
+```go
+subset := lo.WithoutEmpty([]int{0, 2, 10})
+// []int{2, 10}
+```
+
+### WithoutNth
+
+Returns a slice excluding the nth value.
+
+```go
+subset := lo.WithoutNth([]int{-2, -1, 0, 1, 2}, 3, -42, 1)
+// []int{-2, 0, 2}
+```
+
+### ElementsMatch
+
+Returns true if lists contain the same set of elements (including empty set).
+
+If there are duplicate elements, the number of occurrences in each list should match.
+
+The order of elements is not checked.
+
+```go
+b := lo.ElementsMatch([]int{1, 1, 2}, []int{2, 1, 1})
+// true
+```
+
+### ElementsMatchBy
+
+Returns true if lists contain the same set of elements' keys (including empty set).
+
+If there are duplicate keys, the number of occurrences in each list should match.
+
+The order of elements is not checked.
+
+```go
+b := lo.ElementsMatchBy(
+    []someType{a, b},
+    []someType{b, a},
+    func(item someType) string { return item.ID() },
+)
+// true
+```
+
+### IndexOf
+
+Returns the index at which the first occurrence of a value is found in a slice or -1 if the value cannot be found.
+
+```go
+found := lo.IndexOf([]int{0, 1, 2, 1, 2, 3}, 2)
+// 2
+
+notFound := lo.IndexOf([]int{0, 1, 2, 1, 2, 3}, 6)
+// -1
+```
+
+[[play](https://go.dev/play/p/Eo7W0lvKTky)]
+
 ### LastIndexOf
 
-Returns the index at which the last occurrence of a value is found in an array or return -1 if the value cannot be found.
+Returns the index at which the last occurrence of a value is found in a slice or -1 if the value cannot be found.
 
 ```go
-found := lo.LastIndexOf[int]([]int{0, 1, 2, 1, 2, 3}, 2)
+found := lo.LastIndexOf([]int{0, 1, 2, 1, 2, 3}, 2)
 // 4
 
-notFound := lo.LastIndexOf[int]([]int{0, 1, 2, 1, 2, 3}, 6)
+notFound := lo.LastIndexOf([]int{0, 1, 2, 1, 2, 3}, 6)
 // -1
 ```
 
+### HasPrefix
+
+Returns true if the collection has the prefix.
+
+```go
+ok := lo.HasPrefix([]int{1, 2, 3, 4}, []int{42})
+// false
+
+ok := lo.HasPrefix([]int{1, 2, 3, 4}, []int{1, 2})
+// true
+```
+
+[[play](https://go.dev/play/p/SrljzVDpMQM)]
+
+### HasSuffix
+
+Returns true if the collection has the suffix.
+
+```go
+ok := lo.HasSuffix([]int{1, 2, 3, 4}, []int{42})
+// false
+
+ok := lo.HasSuffix([]int{1, 2, 3, 4}, []int{3, 4})
+// true
+```
+
+[[play](https://go.dev/play/p/bJeLetQNAON)]
+
 ### Find
 
-Search an element in a slice based on a predicate. It returns element and true if element was found.
+Searches for an element in a slice based on a predicate. Returns element and true if element was found.
 
 ```go
-str, ok := lo.Find[string]([]string{"a", "b", "c", "d"}, func(i string) bool {
+str, ok := lo.Find([]string{"a", "b", "c", "d"}, func(i string) bool {
     return i == "b"
 })
 // "b", true
 
-str, ok := lo.Find[string]([]string{"foobar"}, func(i string) bool {
+str, ok := lo.Find([]string{"foobar"}, func(i string) bool {
     return i == "b"
 })
 // "", false
 ```
 
+```go
+// Use FindErr when the predicate can return an error
+str, err := lo.FindErr([]string{"a", "b", "c", "d"}, func(i string) (bool, error) {
+    if i == "c" {
+        return false, fmt.Errorf("c is not allowed")
+    }
+    return i == "b", nil
+})
+// "b", nil
+
+str, err = lo.FindErr([]string{"a", "b", "c"}, func(i string) (bool, error) {
+    if i == "b" {
+        return false, fmt.Errorf("b is not allowed")
+    }
+    return i == "b", nil
+})
+// "", error("b is not allowed")
+```
+
+[[play](https://go.dev/play/p/Eo7W0lvKTky)]
+
 ### FindIndexOf
 
-FindIndexOf searches an element in a slice based on a predicate and returns the index and true. It returns -1 and false if the element is not found.
+FindIndexOf searches for an element in a slice based on a predicate and returns the index and true. Returns -1 and false if the element is not found.
 
 ```go
-str, index, ok := lo.FindIndexOf[string]([]string{"a", "b", "a", "b"}, func(i string) bool {
+str, index, ok := lo.FindIndexOf([]string{"a", "b", "a", "b"}, func(i string) bool {
     return i == "b"
 })
 // "b", 1, true
 
-str, index, ok := lo.FindIndexOf[string]([]string{"foobar"}, func(i string) bool {
+str, index, ok := lo.FindIndexOf([]string{"foobar"}, func(i string) bool {
     return i == "b"
 })
 // "", -1, false
 ```
 
+[[play](https://go.dev/play/p/XWSEM4Ic_t0)]
+
 ### FindLastIndexOf
 
-FindLastIndexOf searches an element in a slice based on a predicate and returns the index and true. It returns -1 and false if the element is not found.
+FindLastIndexOf searches for the last element in a slice based on a predicate and returns the index and true. Returns -1 and false if the element is not found.
 
 ```go
-str, index, ok := lo.FindLastIndexOf[string]([]string{"a", "b", "a", "b"}, func(i string) bool {
+str, index, ok := lo.FindLastIndexOf([]string{"a", "b", "a", "b"}, func(i string) bool {
     return i == "b"
 })
 // "b", 4, true
 
-str, index, ok := lo.FindLastIndexOf[string]([]string{"foobar"}, func(i string) bool {
+str, index, ok := lo.FindLastIndexOf([]string{"foobar"}, func(i string) bool {
     return i == "b"
 })
 // "", -1, false
 ```
 
+[[play](https://go.dev/play/p/dPiMRtJ6cUx)]
+
+### FindOrElse
+
+Searches for an element in a slice based on a predicate. Returns the element if found or a given fallback value otherwise.
+
+```go
+str := lo.FindOrElse([]string{"a", "b", "c", "d"}, "x", func(i string) bool {
+    return i == "b"
+})
+// "b"
+
+str := lo.FindOrElse([]string{"foobar"}, "x", func(i string) bool {
+    return i == "b"
+})
+// "x"
+```
+
 ### FindKey
 
 Returns the key of the first value matching.
@@ -1636,7 +3345,7 @@ result3, ok3 := lo.FindKey(map[string]test{"foo": test{"foo"}, "bar": test{"bar"
 
 ### FindKeyBy
 
-Returns the key of the first element predicate returns truthy for.
+Returns the key of the first element predicate returns true for.
 
 ```go
 result1, ok1 := lo.FindKeyBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(k string, v int) bool {
@@ -1652,19 +3361,19 @@ result2, ok2 := lo.FindKeyBy(map[string]int{"foo": 1, "bar": 2, "baz": 3}, func(
 
 ### FindUniques
 
-Returns a slice with all the unique elements of the collection. The order of result values is determined by the order they occur in the array.
+Returns a slice with all the elements that appear in the collection only once. The order of result values is determined by the order they occur in the slice.
 
 ```go
-uniqueValues := lo.FindUniques[int]([]int{1, 2, 2, 1, 2, 3})
+uniqueValues := lo.FindUniques([]int{1, 2, 2, 1, 2, 3})
 // []int{3}
 ```
 
 ### FindUniquesBy
 
-Returns a slice with all the unique elements of the collection. The order of result values is determined by the order they occur in the array. It accepts `iteratee` which is invoked for each element in array to generate the criterion by which uniqueness is computed.
+Returns a slice with all the elements that appear in the collection only once. The order of result values is determined by the order they occur in the slice. It accepts `iteratee` which is invoked for each element in the slice to generate the criterion by which uniqueness is computed.
 
 ```go
-uniqueValues := lo.FindUniquesBy[int, int]([]int{3, 4, 5, 6, 7}, func(i int) int {
+uniqueValues := lo.FindUniquesBy([]int{3, 4, 5, 6, 7}, func(i int) int {
     return i%3
 })
 // []int{5}
@@ -1672,89 +3381,383 @@ uniqueValues := lo.FindUniquesBy[int, int]([]int{3, 4, 5, 6, 7}, func(i int) int
 
 ### FindDuplicates
 
-Returns a slice with the first occurence of each duplicated elements of the collection. The order of result values is determined by the order they occur in the array.
+Returns a slice with the first occurrence of each duplicated element in the collection. The order of result values is determined by the order they occur in the slice.
 
 ```go
-duplicatedValues := lo.FindDuplicates[int]([]int{1, 2, 2, 1, 2, 3})
+duplicatedValues := lo.FindDuplicates([]int{1, 2, 2, 1, 2, 3})
 // []int{1, 2}
 ```
 
 ### FindDuplicatesBy
 
-Returns a slice with the first occurence of each duplicated elements of the collection. The order of result values is determined by the order they occur in the array. It accepts `iteratee` which is invoked for each element in array to generate the criterion by which uniqueness is computed.
+Returns a slice with the first occurrence of each duplicated element in the collection. The order of result values is determined by the order they occur in the slice. It accepts `iteratee` which is invoked for each element in the slice to generate the criterion by which uniqueness is computed.
 
 ```go
-duplicatedValues := lo.FindDuplicatesBy[int, int]([]int{3, 4, 5, 6, 7}, func(i int) int {
+duplicatedValues := lo.FindDuplicatesBy([]int{3, 4, 5, 6, 7}, func(i int) int {
     return i%3
 })
 // []int{3, 4}
 ```
 
+With error handling:
+
+```go
+duplicatedValues, err := lo.FindDuplicatesByErr([]int{3, 4, 5, 6, 7}, func(i int) (int, error) {
+    if i == 5 {
+        return 0, fmt.Errorf("number 5 is not allowed")
+    }
+    return i % 3, nil
+})
+// []int(nil), error("number 5 is not allowed")
+```
+
 ### Min
 
 Search the minimum value of a collection.
 
+Returns zero value when the collection is empty.
+
 ```go
-min := lo.Min[int]([]int{1, 2, 3})
+min := lo.Min([]int{1, 2, 3})
 // 1
 
-min := lo.Min[int]([]int{})
+min := lo.Min([]int{})
 // 0
+
+min := lo.Min([]time.Duration{time.Second, time.Hour})
+// 1s
+```
+
+[[play](https://go.dev/play/p/r6e-Z8JozS8)]
+
+### MinIndex
+
+Search the minimum value of a collection and the index of the minimum value.
+
+Returns (zero value, -1) when the collection is empty.
+
+```go
+min, index := lo.MinIndex([]int{1, 2, 3})
+// 1, 0
+
+min, index := lo.MinIndex([]int{})
+// 0, -1
+
+min, index := lo.MinIndex([]time.Duration{time.Second, time.Hour})
+// 1s, 0
 ```
 
 ### MinBy
 
 Search the minimum value of a collection using the given comparison function.
+
 If several values of the collection are equal to the smallest value, returns the first such value.
 
+Returns zero value when the collection is empty.
+
 ```go
-min := lo.MinBy[string]([]string{"s1", "string2", "s3"}, func(item string, min string) bool {
+min := lo.MinBy([]string{"s1", "string2", "s3"}, func(item string, min string) bool {
     return len(item) < len(min)
 })
 // "s1"
 
-min := lo.MinBy[string]([]string{}, func(item string, min string) bool {
+min := lo.MinBy([]string{}, func(item string, min string) bool {
     return len(item) < len(min)
 })
 // ""
 ```
 
+```go
+// Use MinByErr when the comparison function can return an error
+min, err := lo.MinByErr([]string{"s1", "string2", "s3"}, func(item string, min string) (bool, error) {
+    if item == "string2" {
+        return false, fmt.Errorf("string2 is not allowed")
+    }
+    return len(item) < len(min), nil
+})
+// "s1", error("string2 is not allowed")
+```
+
+### MinIndexBy
+
+Search the minimum value of a collection using the given comparison function and the index of the minimum value.
+
+If several values of the collection are equal to the smallest value, returns the first such value.
+
+Returns (zero value, -1) when the collection is empty.
+
+```go
+min, index := lo.MinIndexBy([]string{"s1", "string2", "s3"}, func(item string, min string) bool {
+    return len(item) < len(min)
+})
+// "s1", 0
+
+min, index := lo.MinIndexBy([]string{}, func(item string, min string) bool {
+    return len(item) < len(min)
+})
+// "", -1
+```
+
+```go
+min, index, err := lo.MinIndexByErr([]string{"s1", "string2", "s3"}, func(item string, min string) (bool, error) {
+    if item == "s2" {
+        return false, fmt.Errorf("s2 is not allowed")
+    }
+    return len(item) < len(min), nil
+})
+// "s1", 0, error("s2 is not allowed")
+```
+
+### Earliest
+
+Search the minimum time.Time of a collection.
+
+Returns zero value when the collection is empty.
+
+```go
+earliest := lo.Earliest(time.Now(), time.Time{})
+// 0001-01-01 00:00:00 +0000 UTC
+```
+
+### EarliestBy
+
+Search the minimum time.Time of a collection using the given iteratee function.
+
+Returns zero value when the collection is empty.
+
+```go
+type foo struct {
+    bar time.Time
+}
+
+earliest := lo.EarliestBy([]foo{{time.Now()}, {}}, func(i foo) time.Time {
+    return i.bar
+})
+// {bar:{2023-04-01 01:02:03 +0000 UTC}}
+```
+
+```go
+// Use EarliestByErr when the iteratee function can return an error
+earliest, err := lo.EarliestByErr([]foo{{time.Now()}, {}}, func(i foo) (time.Time, error) {
+    if i.bar.IsZero() {
+        return time.Time{}, fmt.Errorf("zero time not allowed")
+    }
+    return i.bar, nil
+})
+// {bar:{...}}, error("zero time not allowed")
+```
+
 ### Max
 
 Search the maximum value of a collection.
 
+Returns zero value when the collection is empty.
+
 ```go
-max := lo.Max[int]([]int{1, 2, 3})
+max := lo.Max([]int{1, 2, 3})
 // 3
 
-max := lo.Max[int]([]int{})
+max := lo.Max([]int{})
 // 0
+
+max := lo.Max([]time.Duration{time.Second, time.Hour})
+// 1h
+```
+
+### MaxIndex
+
+Search the maximum value of a collection and the index of the maximum value.
+
+Returns (zero value, -1) when the collection is empty.
+
+```go
+max, index := lo.MaxIndex([]int{1, 2, 3})
+// 3, 2
+
+max, index := lo.MaxIndex([]int{})
+// 0, -1
+
+max, index := lo.MaxIndex([]time.Duration{time.Second, time.Hour})
+// 1h, 1
 ```
 
 ### MaxBy
 
 Search the maximum value of a collection using the given comparison function.
+
 If several values of the collection are equal to the greatest value, returns the first such value.
 
+Returns zero value when the collection is empty.
+
 ```go
-max := lo.MaxBy[string]([]string{"string1", "s2", "string3"}, func(item string, max string) bool {
+max := lo.MaxBy([]string{"string1", "s2", "string3"}, func(item string, max string) bool {
     return len(item) > len(max)
 })
 // "string1"
 
-max := lo.MaxBy[string]([]string{}, func(item string, max string) bool {
+max := lo.MaxBy([]string{}, func(item string, max string) bool {
     return len(item) > len(max)
 })
 // ""
 ```
 
+```go
+// Use MaxByErr when the comparison function can return an error
+max, err := lo.MaxByErr([]string{"string1", "s2", "string3"}, func(item string, max string) (bool, error) {
+    if item == "s2" {
+        return false, fmt.Errorf("s2 is not allowed")
+    }
+    return len(item) > len(max), nil
+})
+// "string1", error("s2 is not allowed")
+```
+
+[[play](https://go.dev/play/p/JW1qu-ECwF7)]
+
+### MaxIndexBy
+
+Search the maximum value of a collection using the given comparison function and the index of the maximum value.
+
+If several values of the collection are equal to the greatest value, returns the first such value.
+
+Returns (zero value, -1) when the collection is empty.
+
+```go
+max, index := lo.MaxIndexBy([]string{"string1", "s2", "string3"}, func(item string, max string) bool {
+    return len(item) > len(max)
+})
+// "string1", 0
+
+max, index := lo.MaxIndexBy([]string{}, func(item string, max string) bool {
+    return len(item) > len(max)
+})
+// "", -1
+```
+
+```go
+// Use MaxIndexByErr when the comparison function can return an error
+max, index, err := lo.MaxIndexByErr([]string{"string1", "s2", "string3"}, func(item string, max string) (bool, error) {
+    if item == "s2" {
+        return false, fmt.Errorf("s2 is not allowed")
+    }
+    return len(item) > len(max), nil
+})
+// "string1", 0, error("s2 is not allowed")
+```
+
+[[play](https://go.dev/play/p/uaUszc-c9QK)]
+
+### Latest
+
+Search the maximum time.Time of a collection.
+
+Returns zero value when the collection is empty.
+
+```go
+latest := lo.Latest(time.Now(), time.Time{})
+// 2023-04-01 01:02:03 +0000 UTC
+```
+
+### LatestBy
+
+Search the maximum time.Time of a collection using the given iteratee function.
+
+Returns zero value when the collection is empty.
+
+```go
+type foo struct {
+    bar time.Time
+}
+
+latest := lo.LatestBy([]foo{{time.Now()}, {}}, func(i foo) time.Time {
+    return i.bar
+})
+// {bar:{2023-04-01 01:02:03 +0000 UTC}}
+```
+
+```go
+// Use LatestByErr when the iteratee function can return an error
+result, err := lo.LatestByErr([]foo{{time.Now()}, {}}, func(i foo) (time.Time, error) {
+    if i.bar.IsZero() {
+        return time.Time{}, fmt.Errorf("zero time not allowed")
+    }
+    return i.bar, nil
+})
+// foo{}, error("zero time not allowed")
+```
+
+### First
+
+Returns the first element of a collection and check for availability of the first element.
+
+```go
+first, ok := lo.First([]int{1, 2, 3})
+// 1, true
+
+first, ok := lo.First([]int{})
+// 0, false
+```
+
+### FirstOrEmpty
+
+Returns the first element of a collection or zero value if empty.
+
+```go
+first := lo.FirstOrEmpty([]int{1, 2, 3})
+// 1
+
+first := lo.FirstOrEmpty([]int{})
+// 0
+```
+
+### FirstOr
+
+Returns the first element of a collection or the fallback value if empty.
+
+```go
+first := lo.FirstOr([]int{1, 2, 3}, 245)
+// 1
+
+first := lo.FirstOr([]int{}, 31)
+// 31
+```
+
 ### Last
 
 Returns the last element of a collection or error if empty.
 
 ```go
-last, err := lo.Last[int]([]int{1, 2, 3})
+last, ok := lo.Last([]int{1, 2, 3})
+// 3
+// true
+
+last, ok := lo.Last([]int{})
+// 0
+// false
+```
+
+### LastOrEmpty
+
+Returns the last element of a collection or zero value if empty.
+
+```go
+last := lo.LastOrEmpty([]int{1, 2, 3})
+// 3
+
+last := lo.LastOrEmpty([]int{})
+// 0
+```
+
+### LastOr
+
+Returns the last element of a collection or the fallback value if empty.
+
+```go
+last := lo.LastOr([]int{1, 2, 3}, 245)
 // 3
+
+last := lo.LastOr([]int{}, 31)
+// 31
 ```
 
 ### Nth
@@ -1762,66 +3765,129 @@ last, err := lo.Last[int]([]int{1, 2, 3})
 Returns the element at index `nth` of collection. If `nth` is negative, the nth element from the end is returned. An error is returned when nth is out of slice bounds.
 
 ```go
-nth, err := lo.Nth[int]([]int{0, 1, 2, 3}, 2)
+nth, err := lo.Nth([]int{0, 1, 2, 3}, 2)
 // 2
 
-nth, err := lo.Nth[int]([]int{0, 1, 2, 3}, -2)
+nth, err := lo.Nth([]int{0, 1, 2, 3}, -2)
 // 2
 ```
 
+### NthOr
+
+Returns the element at index `nth` of the collection. If `nth` is negative, it returns the `nth` element from the end. If `nth` is out of slice bounds, it returns the provided fallback value
+```go
+nth := lo.NthOr([]int{10, 20, 30, 40, 50}, 2, -1)
+// 30
+
+nth := lo.NthOr([]int{10, 20, 30, 40, 50}, -1, -1)
+// 50
+
+nth := lo.NthOr([]int{10, 20, 30, 40, 50}, 5, -1)
+// -1 (fallback value)
+```
+
+### NthOrEmpty
+
+Returns the element at index `nth` of the collection. If `nth` is negative, it returns the `nth` element from the end. If `nth` is out of slice bounds, it returns the zero value for the element type (e.g., 0 for integers, "" for strings, etc).
+``` go
+nth := lo.NthOrEmpty([]int{10, 20, 30, 40, 50}, 2)
+// 30
+
+nth := lo.NthOrEmpty([]int{10, 20, 30, 40, 50}, -1)
+// 50
+
+nth := lo.NthOrEmpty([]int{10, 20, 30, 40, 50}, 5)
+// 0 (zero value for int)
+
+nth := lo.NthOrEmpty([]string{"apple", "banana", "cherry"}, 2)
+// "cherry"
+
+nth := lo.NthOrEmpty([]string{"apple", "banana", "cherry"}, 5)
+// "" (zero value for string)
+```
+
 ### Sample
 
 Returns a random item from collection.
 
 ```go
-lo.Sample[string]([]string{"a", "b", "c"})
+lo.Sample([]string{"a", "b", "c"})
 // a random string from []string{"a", "b", "c"}
 
-lo.Sample[string]([]string{})
+lo.Sample([]string{})
+// ""
+```
+
+[[play](https://go.dev/play/p/FYA45LcpfM2)]
+
+### SampleBy
+
+Returns a random item from collection, using a given random integer generator.
+
+```go
+import "math/rand"
+
+r := rand.New(rand.NewSource(42))
+lo.SampleBy([]string{"a", "b", "c"}, r.Intn)
+// a random string from []string{"a", "b", "c"}, using a seeded random generator
+
+lo.SampleBy([]string{}, r.Intn)
 // ""
 ```
 
 ### Samples
 
-Returns N random unique items from collection.
+Returns N random unique items from collection.
+
+```go
+lo.Samples([]string{"a", "b", "c"}, 3)
+// []string{"a", "b", "c"} in random order
+```
+
+### SamplesBy
+
+Returns N random unique items from collection, using a given random integer generator.
 
 ```go
-lo.Samples[string]([]string{"a", "b", "c"}, 3)
-// []string{"a", "b", "c"} in random order
+r := rand.New(rand.NewSource(42))
+lo.SamplesBy([]string{"a", "b", "c"}, 3, r.Intn)
+// []string{"a", "b", "c"} in random order, using a seeded random generator
 ```
 
 ### Ternary
 
-A 1 line if/else statement.
+A single line if/else statement.
 
 ```go
-result := lo.Ternary[string](true, "a", "b")
+result := lo.Ternary(true, "a", "b")
 // "a"
 
-result := lo.Ternary[string](false, "a", "b")
+result := lo.Ternary(false, "a", "b")
 // "b"
 ```
 
+Take care to avoid dereferencing potentially nil pointers in your A/B expressions, because they are both evaluated. See TernaryF to avoid this problem.
+
 [[play](https://go.dev/play/p/t-D7WBL44h2)]
 
 ### TernaryF
 
-A 1 line if/else statement whose options are functions.
+A single line if/else statement whose options are functions.
 
 ```go
-result := lo.TernaryF[string](true, func() string { return "a" }, func() string { return "b" })
+result := lo.TernaryF(true, func() string { return "a" }, func() string { return "b" })
 // "a"
 
-result := lo.TernaryF[string](false, func() string { return "a" }, func() string { return "b" })
+result := lo.TernaryF(false, func() string { return "a" }, func() string { return "b" })
 // "b"
 ```
 
-Useful to avoid nil-pointer dereferencing in intializations, or avoid running unnecessary code
+Useful to avoid nil-pointer dereferencing in initializations, or avoid running unnecessary code
 
 ```go
 var s *string
 
-someStr := TernaryF[string](s == nil, func() string { return uuid.New().String() }, func() string { return *s })
+someStr := TernaryF(s == nil, func() string { return uuid.New().String() }, func() string { return *s })
 // ef782193-c30c-4e2e-a7ae-f8ab5e125e02
 ```
 
@@ -1830,17 +3896,17 @@ someStr := TernaryF[string](s == nil, func() string { return uuid.New().String()
 ### If / ElseIf / Else
 
 ```go
-result := lo.If[int](true, 1).
+result := lo.If(true, 1).
     ElseIf(false, 2).
     Else(3)
 // 1
 
-result := lo.If[int](false, 1).
+result := lo.If(false, 1).
     ElseIf(true, 2).
     Else(3)
 // 2
 
-result := lo.If[int](false, 1).
+result := lo.If(false, 1).
     ElseIf(false, 2).
     Else(3)
 // 3
@@ -1849,7 +3915,7 @@ result := lo.If[int](false, 1).
 Using callbacks:
 
 ```go
-result := lo.IfF[int](true, func () int {
+result := lo.IfF(true, func () int {
         return 1
     }).
     ElseIfF(false, func () int {
@@ -1864,7 +3930,7 @@ result := lo.IfF[int](true, func () int {
 Mixed:
 
 ```go
-result := lo.IfF[int](true, func () int {
+result := lo.IfF(true, func () int {
         return 1
     }).
     Else(42)
@@ -1876,19 +3942,19 @@ result := lo.IfF[int](true, func () int {
 ### Switch / Case / Default
 
 ```go
-result := lo.Switch[int, string](1).
+result := lo.Switch(1).
     Case(1, "1").
     Case(2, "2").
     Default("3")
 // "1"
 
-result := lo.Switch[int, string](2).
+result := lo.Switch(2).
     Case(1, "1").
     Case(2, "2").
     Default("3")
 // "2"
 
-result := lo.Switch[int, string](42).
+result := lo.Switch(42).
     Case(1, "1").
     Case(2, "2").
     Default("3")
@@ -1898,7 +3964,7 @@ result := lo.Switch[int, string](42).
 Using callbacks:
 
 ```go
-result := lo.Switch[int, string](1).
+result := lo.Switch(1).
     CaseF(1, func() string {
         return "1"
     }).
@@ -1914,7 +3980,7 @@ result := lo.Switch[int, string](1).
 Mixed:
 
 ```go
-result := lo.Switch[int, string](1).
+result := lo.Switch(1).
     CaseF(1, func() string {
         return "1"
     }).
@@ -1924,12 +3990,90 @@ result := lo.Switch[int, string](1).
 
 [[play](https://go.dev/play/p/TGbKUMAeRUd)]
 
+### IsNil
+
+Checks if a value is nil or if it's a reference type with a nil underlying value.
+
+```go
+var x int
+lo.IsNil(x)
+// false
+
+var k struct{}
+lo.IsNil(k)
+// false
+
+var i *int
+lo.IsNil(i)
+// true
+
+var ifaceWithNilValue any = (*string)(nil)
+lo.IsNil(ifaceWithNilValue)
+// true
+ifaceWithNilValue == nil
+// false
+```
+
+### IsNotNil
+
+Checks if a value is not nil or if it's not a reference type with a nil underlying value.
+
+```go
+var x int
+lo.IsNotNil(x)
+// true
+
+var k struct{}
+lo.IsNotNil(k)
+// true
+
+var i *int
+lo.IsNotNil(i)
+// false
+
+var ifaceWithNilValue any = (*string)(nil)
+lo.IsNotNil(ifaceWithNilValue)
+// false
+ifaceWithNilValue == nil
+// true
+```
+
 ### ToPtr
 
-Returns a pointer copy of value.
+Returns a pointer copy of the value.
+
+```go
+ptr := lo.ToPtr("hello world")
+// *string{"hello world"}
+```
+
+[[play](https://go.dev/play/p/P2sD0PMXw4F)]
+
+### Nil
+
+Returns a nil pointer of type.
+
+```go
+ptr := lo.Nil[float64]()
+// nil
+```
+
+### EmptyableToPtr
+
+Returns a pointer copy of value if it's nonzero.
+Otherwise, returns nil pointer.
 
 ```go
-ptr := lo.ToPtr[string]("hello world")
+ptr := lo.EmptyableToPtr(nil)
+// nil
+
+ptr := lo.EmptyableToPtr("")
+// nil
+
+ptr := lo.EmptyableToPtr([]int{})
+// *[]int{}
+
+ptr := lo.EmptyableToPtr("hello world")
 // *string{"hello world"}
 ```
 
@@ -1939,10 +4083,10 @@ Returns the pointer value or empty.
 
 ```go
 str := "hello world"
-value := lo.FromPtr[string](&str)
+value := lo.FromPtr(&str)
 // "hello world"
 
-value := lo.FromPtr[string](nil)
+value := lo.FromPtr(nil)
 // ""
 ```
 
@@ -1952,46 +4096,78 @@ Returns the pointer value or the fallback value.
 
 ```go
 str := "hello world"
-value := lo.FromPtrOr[string](&str, "empty")
+value := lo.FromPtrOr(&str, "empty")
 // "hello world"
 
-value := lo.FromPtrOr[string](nil, "empty")
+value := lo.FromPtrOr(nil, "empty")
 // "empty"
 ```
 
 ### ToSlicePtr
 
-Returns a slice of pointer copy of value.
+Returns a slice of pointers to each value.
 
 ```go
-ptr := lo.ToSlicePtr[string]([]string{"hello", "world"})
+ptr := lo.ToSlicePtr([]string{"hello", "world"})
 // []*string{"hello", "world"}
 ```
 
+### FromSlicePtr
+
+Returns a slice with the pointer values.
+Returns a zero value in case of a nil pointer element.
+
+```go
+str1 := "hello"
+str2 := "world"
+
+ptr := lo.FromSlicePtr[string]([]*string{&str1, &str2, nil})
+// []string{"hello", "world", ""}
+
+ptr := lo.Compact(
+    lo.FromSlicePtr[string]([]*string{&str1, &str2, nil}),
+)
+// []string{"hello", "world"}
+```
+
+### FromSlicePtrOr
+
+Returns a slice with the pointer values or the fallback value.
+
+```go
+str1 := "hello"
+str2 := "world"
+
+ptr := lo.FromSlicePtrOr([]*string{&str1, nil, &str2}, "fallback value")
+// []string{"hello", "fallback value", "world"}
+```
+
+[[play](https://go.dev/play/p/CuXGVzo9G65)]
+
 ### ToAnySlice
 
 Returns a slice with all elements mapped to `any` type.
 
 ```go
-elements := lo.ToAnySlice[int]([]int{1, 5, 1})
+elements := lo.ToAnySlice([]int{1, 5, 1})
 // []any{1, 5, 1}
 ```
 
 ### FromAnySlice
 
-Returns an `any` slice with all elements mapped to a type. Returns false in case of type conversion failure.
+Returns a slice with all elements mapped to a type. Returns false in case of type conversion failure.
 
 ```go
-elements, ok := lo.FromAnySlice[string]([]any{"foobar", 42})
+elements, ok := lo.FromAnySlice([]any{"foobar", 42})
 // []string{}, false
 
-elements, ok := lo.FromAnySlice[string]([]any{"foobar", "42"})
+elements, ok := lo.FromAnySlice([]any{"foobar", "42"})
 // []string{"foobar", "42"}, true
 ```
 
 ### Empty
 
-Returns an empty value.
+Returns the [zero value](https://go.dev/ref/spec#The_zero_value).
 
 ```go
 lo.Empty[int]()
@@ -2007,23 +4183,23 @@ lo.Empty[bool]()
 Returns true if argument is a zero value.
 
 ```go
-lo.IsEmpty[int](0)
+lo.IsEmpty(0)
 // true
-lo.IsEmpty[int](42)
+lo.IsEmpty(42)
 // false
 
-lo.IsEmpty[string]("")
+lo.IsEmpty("")
 // true
-lo.IsEmpty[bool]("foobar")
+lo.IsEmpty("foobar")
 // false
 
 type test struct {
     foobar string
 }
 
-lo.IsEmpty[test](test{foobar: ""})
+lo.IsEmpty(test{foobar: ""})
 // true
-lo.IsEmpty[test](test{foobar: "foobar"})
+lo.IsEmpty(test{foobar: "foobar"})
 // false
 ```
 
@@ -2032,23 +4208,23 @@ lo.IsEmpty[test](test{foobar: "foobar"})
 Returns true if argument is a zero value.
 
 ```go
-lo.IsNotEmpty[int](0)
+lo.IsNotEmpty(0)
 // false
-lo.IsNotEmpty[int](42)
+lo.IsNotEmpty(42)
 // true
 
-lo.IsNotEmpty[string]("")
+lo.IsNotEmpty("")
 // false
-lo.IsNotEmpty[bool]("foobar")
+lo.IsNotEmpty("foobar")
 // true
 
 type test struct {
     foobar string
 }
 
-lo.IsNotEmpty[test](test{foobar: ""})
+lo.IsNotEmpty(test{foobar: ""})
 // false
-lo.IsNotEmpty[test](test{foobar: "foobar"})
+lo.IsNotEmpty(test{foobar: "foobar"})
 // true
 ```
 
@@ -2065,10 +4241,87 @@ result, ok := lo.Coalesce("")
 
 var nilStr *string
 str := "foobar"
-result, ok := lo.Coalesce[*string](nil, nilStr, &str)
+result, ok := lo.Coalesce(nil, nilStr, &str)
 // &"foobar" true
 ```
 
+### CoalesceOrEmpty
+
+Returns the first non-empty arguments. Arguments must be comparable.
+
+```go
+result := lo.CoalesceOrEmpty(0, 1, 2, 3)
+// 1
+
+result := lo.CoalesceOrEmpty("")
+// ""
+
+var nilStr *string
+str := "foobar"
+result := lo.CoalesceOrEmpty(nil, nilStr, &str)
+// &"foobar"
+```
+
+### CoalesceSlice
+
+Returns the first non-zero slice.
+
+```go
+result, ok := lo.CoalesceSlice([]int{1, 2, 3}, []int{4, 5, 6})
+// [1, 2, 3]
+// true
+
+result, ok := lo.CoalesceSlice(nil, []int{})
+// []
+// true
+
+result, ok := lo.CoalesceSlice([]int(nil))
+// []
+// false
+```
+
+### CoalesceSliceOrEmpty
+
+Returns the first non-zero slice.
+
+```go
+result := lo.CoalesceSliceOrEmpty([]int{1, 2, 3}, []int{4, 5, 6})
+// [1, 2, 3]
+
+result := lo.CoalesceSliceOrEmpty(nil, []int{})
+// []
+```
+
+### CoalesceMap
+
+Returns the first non-zero map.
+
+```go
+result, ok := lo.CoalesceMap(map[string]int{"1": 1, "2": 2, "3": 3}, map[string]int{"4": 4, "5": 5, "6": 6})
+// {"1": 1, "2": 2, "3": 3}
+// true
+
+result, ok := lo.CoalesceMap(nil, map[string]int{})
+// {}
+// true
+
+result, ok := lo.CoalesceMap(map[string]int(nil))
+// {}
+// false
+```
+
+### CoalesceMapOrEmpty
+
+Returns the first non-zero map.
+
+```go
+result := lo.CoalesceMapOrEmpty(map[string]int{"1": 1, "2": 2, "3": 3}, map[string]int{"4": 4, "5": 5, "6": 6})
+// {"1": 1, "2": 2, "3": 3}
+
+result := lo.CoalesceMapOrEmpty(nil, map[string]int{})
+// {}
+```
+
 ### Partial
 
 Returns new function that, when called, has its first argument set to the provided value.
@@ -2084,9 +4337,30 @@ f(42)
 // 47
 ```
 
+[[play](https://go.dev/play/p/Sy1gAQiQZ3v)]
+
+### Partial2 -> Partial5
+
+Returns new function that, when called, has its first argument set to the provided value.
+
+```go
+add := func(x, y, z int) int { return x + y + z }
+f := lo.Partial2(add, 42)
+
+f(10, 5)
+// 57
+
+f(42, -4)
+// 80
+```
+
+[[play](https://go.dev/play/p/-xiPjy4JChJ)]
+
 ### Attempt
 
-Invokes a function N times until it returns valid output. Returning either the caught error or nil. When first argument is less than `1`, the function runs until a successful response is returned.
+Invokes a function N times until it returns valid output. Returns either the caught error or nil.
+
+When the first argument is less than `1`, the function runs until a successful response is returned.
 
 ```go
 iter, err := lo.Attempt(42, func(i int) error {
@@ -2094,7 +4368,7 @@ iter, err := lo.Attempt(42, func(i int) error {
         return nil
     }
 
-    return fmt.Errorf("failed")
+    return errors.New("failed")
 })
 // 6
 // nil
@@ -2104,14 +4378,14 @@ iter, err := lo.Attempt(2, func(i int) error {
         return nil
     }
 
-    return fmt.Errorf("failed")
+    return errors.New("failed")
 })
 // 2
 // error "failed"
 
 iter, err := lo.Attempt(0, func(i int) error {
     if i < 42 {
-        return fmt.Errorf("failed")
+        return errors.New("failed")
     }
 
     return nil
@@ -2120,15 +4394,15 @@ iter, err := lo.Attempt(0, func(i int) error {
 // nil
 ```
 
-For more advanced retry strategies (delay, exponential backoff...), please take a look on [cenkalti/backoff](https://github.com/cenkalti/backoff).
+For more advanced retry strategies (delay, exponential backoff...), please take a look at [cenkalti/backoff](https://github.com/cenkalti/backoff).
 
 [[play](https://go.dev/play/p/3ggJZ2ZKcMj)]
 
 ### AttemptWithDelay
 
-Invokes a function N times until it returns valid output, with a pause between each call. Returning either the caught error or nil.
+Invokes a function N times until it returns valid output, with a pause between each call. Returns either the caught error or nil.
 
-When first argument is less than `1`, the function runs until a successful response is returned.
+When the first argument is less than `1`, the function runs until a successful response is returned.
 
 ```go
 iter, duration, err := lo.AttemptWithDelay(5, 2*time.Second, func(i int, duration time.Duration) error {
@@ -2136,17 +4410,67 @@ iter, duration, err := lo.AttemptWithDelay(5, 2*time.Second, func(i int, duratio
         return nil
     }
 
-    return fmt.Errorf("failed")
+    return errors.New("failed")
 })
 // 3
 // ~ 4 seconds
 // nil
 ```
 
-For more advanced retry strategies (delay, exponential backoff...), please take a look on [cenkalti/backoff](https://github.com/cenkalti/backoff).
+For more advanced retry strategies (delay, exponential backoff...), please take a look at [cenkalti/backoff](https://github.com/cenkalti/backoff).
 
 [[play](https://go.dev/play/p/tVs6CygC7m1)]
 
+### AttemptWhile
+
+Invokes a function N times until it returns valid output. Returns either the caught error or nil, along with a bool value to determine whether the function should be invoked again. It will terminate the invoke immediately if the second return value is false.
+
+When the first argument is less than `1`, the function runs until a successful response is returned.
+
+```go
+count1, err1 := lo.AttemptWhile(5, func(i int) (error, bool) {
+    err := doMockedHTTPRequest(i)
+    if err != nil {
+        if errors.Is(err, ErrBadRequest) { // let's assume ErrBadRequest is a critical error that needs to terminate the invoke
+            return err, false // flag the second return value as false to terminate the invoke
+        }
+
+        return err, true
+    }
+
+    return nil, false
+})
+```
+
+For more advanced retry strategies (delay, exponential backoff...), please take a look at [cenkalti/backoff](https://github.com/cenkalti/backoff).
+
+[[play](https://go.dev/play/p/1VS7HxlYMOG)]
+
+### AttemptWhileWithDelay
+
+Invokes a function N times until it returns valid output, with a pause between each call. Returns either the caught error or nil, along with a bool value to determine whether the function should be invoked again. It will terminate the invoke immediately if the second return value is false.
+
+When the first argument is less than `1`, the function runs until a successful response is returned.
+
+```go
+count1, time1, err1 := lo.AttemptWhileWithDelay(5, time.Millisecond, func(i int, d time.Duration) (error, bool) {
+    err := doMockedHTTPRequest(i)
+    if err != nil {
+        if errors.Is(err, ErrBadRequest) { // let's assume ErrBadRequest is a critical error that needs to terminate the invoke
+            return err, false // flag the second return value as false to terminate the invoke
+        }
+
+        return err, true
+    }
+
+    return nil, false
+})
+```
+
+For more advanced retry strategies (delay, exponential backoff...), please take a look at [cenkalti/backoff](https://github.com/cenkalti/backoff).
+
+[[play](https://go.dev/play/p/mhufUjJfLEF)]
+
 ### Debounce
 
 `NewDebounce` creates a debounced instance that delays invoking functions given until after wait milliseconds have elapsed, until `cancel` is called.
@@ -2167,6 +4491,86 @@ cancel()
 
 [[play](https://go.dev/play/p/mz32VMK2nqe)]
 
+### DebounceBy
+
+`NewDebounceBy` creates a debounced instance for each distinct key, that delays invoking functions given until after wait milliseconds have elapsed, until `cancel` is called.
+
+```go
+f := func(key string, count int) {
+    println(key + ": Called once after 100ms when debounce stopped invoking!")
+}
+
+debounce, cancel := lo.NewDebounceBy(100 * time.Millisecond, f)
+for j := 0; j < 10; j++ {
+    debounce("first key")
+    debounce("second key")
+}
+
+time.Sleep(1 * time.Second)
+cancel("first key")
+cancel("second key")
+```
+
+[[play](https://go.dev/play/p/d3Vpt6pxhY8)]
+
+### Throttle
+
+Creates a throttled instance that invokes given functions only once in every interval.
+
+This returns 2 functions, First one is throttled function and Second one is a function to reset interval.
+
+```go
+f := func() {
+	println("Called once in every 100ms")
+}
+
+throttle, reset := lo.NewThrottle(100 * time.Millisecond, f)
+
+for j := 0; j < 10; j++ {
+	throttle()
+	time.Sleep(30 * time.Millisecond)
+}
+
+reset()
+throttle()
+```
+
+`NewThrottleWithCount` is NewThrottle with count limit, throttled function will be invoked count times in every interval.
+
+```go
+f := func() {
+	println("Called three times in every 100ms")
+}
+
+throttle, reset := lo.NewThrottleWithCount(100 * time.Millisecond, f)
+
+for j := 0; j < 10; j++ {
+	throttle()
+	time.Sleep(30 * time.Millisecond)
+}
+
+reset()
+throttle()
+```
+
+`NewThrottleBy` and `NewThrottleByWithCount` are NewThrottle with sharding key, throttled function will be invoked count times in every interval.
+
+```go
+f := func(key string) {
+	println(key, "Called three times in every 100ms")
+}
+
+throttle, reset := lo.NewThrottleByWithCount(100 * time.Millisecond, f)
+
+for j := 0; j < 10; j++ {
+	throttle("foo")
+	time.Sleep(30 * time.Millisecond)
+}
+
+reset()
+throttle()
+```
+
 ### Synchronize
 
 Wraps the underlying callback in a mutex. It receives an optional mutex.
@@ -2206,8 +4610,8 @@ ch := lo.Async(func() error { time.Sleep(10 * time.Second); return nil })
 ### Async{0->6}
 
 Executes a function in a goroutine and returns the result in a channel.
-For function with multiple return values, the results will be returned as a tuple inside the channel.
-For function without return, struct{} will be returned in the channel.
+For functions with multiple return values, the results will be returned as a tuple inside the channel.
+For functions without return, struct{} will be returned in the channel.
 
 ```go
 ch := lo.Async0(func() { time.Sleep(10 * time.Second) })
@@ -2226,6 +4630,136 @@ ch := lo.Async2(func() (int, string) {
 // chan lo.Tuple2[int, string] ({42, "Hello"})
 ```
 
+### Transaction
+
+Implements a Saga pattern.
+
+```go
+transaction := NewTransaction().
+    Then(
+        func(state int) (int, error) {
+            fmt.Println("step 1")
+            return state + 10, nil
+        },
+        func(state int) int {
+            fmt.Println("rollback 1")
+            return state - 10
+        },
+    ).
+    Then(
+        func(state int) (int, error) {
+            fmt.Println("step 2")
+            return state + 15, nil
+        },
+        func(state int) int {
+            fmt.Println("rollback 2")
+            return state - 15
+        },
+    ).
+    Then(
+        func(state int) (int, error) {
+            fmt.Println("step 3")
+
+            if true {
+                return state, errors.New("error")
+            }
+
+            return state + 42, nil
+        },
+        func(state int) int {
+            fmt.Println("rollback 3")
+            return state - 42
+        },
+    )
+
+_, _ = transaction.Process(-5)
+
+// Output:
+// step 1
+// step 2
+// step 3
+// rollback 2
+// rollback 1
+```
+
+### WaitFor
+
+Runs periodically until a condition is validated.
+
+```go
+alwaysTrue := func(i int) bool { return true }
+alwaysFalse := func(i int) bool { return false }
+laterTrue := func(i int) bool {
+    return i > 5
+}
+
+iterations, duration, ok := lo.WaitFor(alwaysTrue, 10*time.Millisecond, 2 * time.Millisecond)
+// 1
+// 1ms
+// true
+
+iterations, duration, ok := lo.WaitFor(alwaysFalse, 10*time.Millisecond, time.Millisecond)
+// 10
+// 10ms
+// false
+
+iterations, duration, ok := lo.WaitFor(laterTrue, 10*time.Millisecond, time.Millisecond)
+// 7
+// 7ms
+// true
+
+iterations, duration, ok := lo.WaitFor(laterTrue, 10*time.Millisecond, 5*time.Millisecond)
+// 2
+// 10ms
+// false
+```
+
+[[play](https://go.dev/play/p/t_wTDmubbK3)]
+
+### WaitForWithContext
+
+Runs periodically until a condition is validated or context is invalid.
+
+The condition receives also the context, so it can invalidate the process in the condition checker
+
+```go
+ctx := context.Background()
+
+alwaysTrue := func(_ context.Context, i int) bool { return true }
+alwaysFalse := func(_ context.Context, i int) bool { return false }
+laterTrue := func(_ context.Context, i int) bool {
+    return i >= 5
+}
+
+iterations, duration, ok := lo.WaitForWithContext(ctx, alwaysTrue, 10*time.Millisecond, 2 * time.Millisecond)
+// 1
+// 1ms
+// true
+
+iterations, duration, ok := lo.WaitForWithContext(ctx, alwaysFalse, 10*time.Millisecond, time.Millisecond)
+// 10
+// 10ms
+// false
+
+iterations, duration, ok := lo.WaitForWithContext(ctx, laterTrue, 10*time.Millisecond, time.Millisecond)
+// 5
+// 5ms
+// true
+
+iterations, duration, ok := lo.WaitForWithContext(ctx, laterTrue, 10*time.Millisecond, 5*time.Millisecond)
+// 2
+// 10ms
+// false
+
+expiringCtx, cancel := context.WithTimeout(ctx, 5*time.Millisecond)
+iterations, duration, ok := lo.WaitForWithContext(expiringCtx, alwaysFalse, 100*time.Millisecond, time.Millisecond)
+// 5
+// 5.1ms
+// false
+```
+
+[[play](https://go.dev/play/p/t_wTDmubbK3)]
+
 ### Validate
 
 Helper function that creates an error when a condition is not met.
@@ -2244,7 +4778,7 @@ val := lo.Validate(len(slice) == 0, "Slice should be empty but contains %v", sli
 
 ### Must
 
-Wraps a function call to panics if second argument is `error` or `false`, returns the value otherwise.
+Wraps a function call and panics if second argument is `error` or `false`, returns the value otherwise.
 
 ```go
 val := lo.Must(time.Parse("2006-01-02", "2022-01-15"))
@@ -2258,7 +4792,7 @@ val := lo.Must(time.Parse("2006-01-02", "bad-value"))
 
 ### Must{0->6}
 
-Must\* has the same behavior than Must, but returns multiple values.
+Must\* has the same behavior as Must but returns multiple values.
 
 ```go
 func example0() (error)
@@ -2298,7 +4832,7 @@ lo.Must0(ok, "'%s' must always contain '%s'", myString, requiredChar)
 
 list := []int{0, 1, 2}
 item := 5
-lo.Must0(lo.Contains[int](list, item), "'%s' must always contain '%s'", list, item)
+lo.Must0(lo.Contains(list, item), "'%s' must always contain '%s'", list, item)
 ...
 ```
 
@@ -2306,7 +4840,7 @@ lo.Must0(lo.Contains[int](list, item), "'%s' must always contain '%s'", list, it
 
 ### Try
 
-Calls the function and return false in case of error and on panic.
+Calls the function and returns false in case of error and panic.
 
 ```go
 ok := lo.Try(func() error {
@@ -2321,7 +4855,7 @@ ok := lo.Try(func() error {
 // true
 
 ok := lo.Try(func() error {
-    return fmt.Errorf("error")
+    return errors.New("error")
 })
 // false
 ```
@@ -2330,7 +4864,7 @@ ok := lo.Try(func() error {
 
 ### Try{0->6}
 
-The same behavior than `Try`, but callback returns 2 variables.
+The same behavior as `Try`, but the callback returns 2 variables.
 
 ```go
 ok := lo.Try2(func() (string, error) {
@@ -2354,14 +4888,14 @@ str, ok := lo.TryOr(func() (string, error) {
 // world
 // false
 
-ok := lo.TryOr(func() error {
+str, ok := lo.TryOr(func() error {
     return "hello", nil
 }, "world")
 // hello
 // true
 
-ok := lo.TryOr(func() error {
-    return "hello", fmt.Errorf("error")
+str, ok := lo.TryOr(func() error {
+    return "hello", errors.New("error")
 }, "world")
 // world
 // false
@@ -2371,7 +4905,7 @@ ok := lo.TryOr(func() error {
 
 ### TryOr{0->6}
 
-The same behavior than `TryOr`, but callback returns 2 variables.
+The same behavior as `TryOr`, but the callback returns `X` variables.
 
 ```go
 str, nbr, ok := lo.TryOr2(func() (string, int, error) {
@@ -2387,7 +4921,7 @@ str, nbr, ok := lo.TryOr2(func() (string, int, error) {
 
 ### TryWithErrorValue
 
-The same behavior than `Try`, but also returns value passed to panic.
+The same behavior as `Try`, but also returns the value passed to panic.
 
 ```go
 err, ok := lo.TryWithErrorValue(func() error {
@@ -2401,7 +4935,7 @@ err, ok := lo.TryWithErrorValue(func() error {
 
 ### TryCatch
 
-The same behavior than `Try`, but calls the catch function in case of error.
+The same behavior as `Try`, but calls the catch function in case of error.
 
 ```go
 caught := false
@@ -2420,7 +4954,7 @@ ok := lo.TryCatch(func() error {
 
 ### TryCatchWithErrorValue
 
-The same behavior than `TryWithErrorValue`, but calls the catch function in case of error.
+The same behavior as `TryWithErrorValue`, but calls the catch function in case of error.
 
 ```go
 caught := false
@@ -2450,7 +4984,7 @@ if ok := errors.As(err, &rateLimitErr); ok {
 }
 ```
 
-1 line `lo` helper:
+single line `lo` helper:
 
 ```go
 err := doSomething()
@@ -2462,11 +4996,45 @@ if rateLimitErr, ok := lo.ErrorsAs[*RateLimitError](err); ok {
 
 [[play](https://go.dev/play/p/8wk5rH8UfrE)]
 
+### Assert
+
+Does nothing when the condition is `true`, otherwise it panics with an optional message.
+
+Think twice before using it, given that [Go intentionally omits assertions from its standard library](https://go.dev/doc/faq#assertions).
+
+```go
+age := getUserAge()
+
+lo.Assert(age >= 15)
+```
+
+```go
+age := getUserAge()
+
+lo.Assert(age >= 15, "user age must be >= 15")
+```
+
+[[play](https://go.dev/play/p/Xv8LLKBMNwI)]
+
+### Assertf
+
+Like `Assert`, but with `fmt.Printf`-like formatting.
+
+Think twice before using it, given that [Go intentionally omits assertions from its standard library](https://go.dev/doc/faq#assertions).
+
+```go
+age := getUserAge()
+
+lo.Assertf(age >= 15, "user age must be >= 15, got %d", age)
+```
+
+[[play](https://go.dev/play/p/TVPEmVcyrdY)]
+
 ## 🛩 Benchmark
 
-We executed a simple benchmark with the a dead-simple `lo.Map` loop:
+We executed a simple benchmark with a dead-simple `lo.Map` loop:
 
-See the full implementation [here](./benchmark_test.go).
+See the full implementation [here](./map_benchmark_test.go).
 
 ```go
 _ = lo.Map[int64](arr, func(x int64, i int) string {
@@ -2478,7 +5046,7 @@ _ = lo.Map[int64](arr, func(x int64, i int) string {
 
 Here is a comparison between `lo.Map`, `lop.Map`, `go-funk` library and a simple Go `for` loop.
 
-```
+```shell
 $ go test -benchmem -bench ./...
 goos: linux
 goarch: amd64
@@ -2494,26 +5062,20 @@ ok  	github.com/samber/lo	6.657s
 ```
 
 - `lo.Map` is way faster (x7) than `go-funk`, a reflection-based Map implementation.
-- `lo.Map` have the same allocation profile than `for`.
+- `lo.Map` has the same allocation profile as `for`.
 - `lo.Map` is 4% slower than `for`.
-- `lop.Map` is slower than `lo.Map` because it implies more memory allocation and locks. `lop.Map` will be useful for long-running callbacks, such as i/o bound processing.
+- `lop.Map` is slower than `lo.Map` because it implies more memory allocation and locks. `lop.Map` is useful for long-running callbacks, such as i/o bound processing.
 - `for` beats other implementations for memory and CPU.
 
 ## 🤝 Contributing
 
-- Ping me on twitter [@samuelberthe](https://twitter.com/samuelberthe) (DMs, mentions, whatever :))
+- Ping me on Twitter [@samuelberthe](https://twitter.com/samuelberthe) (DMs, mentions, whatever :))
 - Fork the [project](https://github.com/samber/lo)
 - Fix [open issues](https://github.com/samber/lo/issues) or request new features
 
 Don't hesitate ;)
 
-### With Docker
-
-```bash
-docker-compose run --rm dev
-```
-
-### Without Docker
+Helper naming: helpers must be self-explanatory and respect standards (other languages, libraries...). Feel free to suggest many names in your contributions.
 
 ```bash
 # Install some dev dependencies
@@ -2525,18 +5087,18 @@ make test
 make watch-test
 ```
 
-## 👤 Authors
+## 👤 Contributors
 
-- Samuel Berthe
+![Contributors](https://contrib.rocks/image?repo=samber/lo)
 
 ## 💫 Show your support
 
 Give a ⭐️ if this project helped you!
 
-[![support us](https://c5.patreon.com/external/logo/become_a_patron_button.png)](https://www.patreon.com/samber)
+[![GitHub Sponsors](https://img.shields.io/github/sponsors/samber?style=for-the-badge)](https://github.com/sponsors/samber)
 
 ## 📝 License
 
 Copyright © 2022 [Samuel Berthe](https://github.com/samber).
 
-This project is [MIT](./LICENSE) licensed.
+This project is under [MIT](./LICENSE) license.
diff --git a/vendor/github.com/samber/lo/channel.go b/vendor/github.com/samber/lo/channel.go
index ccbd36028ff..5c7dd9ebd2a 100644
--- a/vendor/github.com/samber/lo/channel.go
+++ b/vendor/github.com/samber/lo/channel.go
@@ -1,16 +1,21 @@
 package lo
 
 import (
-	"math/rand"
+	"context"
+	"sync"
 	"time"
+
+	"github.com/samber/lo/internal/xrand"
 )
 
+// DispatchingStrategy is a function that distributes messages to channels.
 type DispatchingStrategy[T any] func(msg T, index uint64, channels []<-chan T) int
 
 // ChannelDispatcher distributes messages from input channels into N child channels.
 // Close events are propagated to children.
 // Underlying channels can have a fixed buffer capacity or be unbuffered when cap is 0.
-func ChannelDispatcher[T any](stream <-chan T, count int, channelBufferCap int, strategy DispatchingStrategy[T]) []<-chan T {
+// Play: https://go.dev/play/p/UZGu2wVg3J2
+func ChannelDispatcher[T any](stream <-chan T, count, channelBufferCap int, strategy DispatchingStrategy[T]) []<-chan T {
 	children := createChannels[T](count, channelBufferCap)
 
 	roChildren := channelsToReadOnly(children)
@@ -19,14 +24,9 @@ func ChannelDispatcher[T any](stream <-chan T, count int, channelBufferCap int,
 		// propagate channel closing to children
 		defer closeChannels(children)
 
-		var i uint64 = 0
-
-		for {
-			msg, ok := <-stream
-			if !ok {
-				return
-			}
+		var i uint64
 
+		for msg := range stream {
 			destination := strategy(msg, i, roChildren) % count
 			children[destination] <- msg
 
@@ -37,7 +37,7 @@ func ChannelDispatcher[T any](stream <-chan T, count int, channelBufferCap int,
 	return roChildren
 }
 
-func createChannels[T any](count int, channelBufferCap int) []chan T {
+func createChannels[T any](count, channelBufferCap int) []chan T {
 	children := make([]chan T, 0, count)
 
 	for i := 0; i < count; i++ {
@@ -69,6 +69,7 @@ func channelIsNotFull[T any](ch <-chan T) bool {
 
 // DispatchingStrategyRoundRobin distributes messages in a rotating sequential manner.
 // If the channel capacity is exceeded, the next channel will be selected and so on.
+// Play: https://go.dev/play/p/UZGu2wVg3J2
 func DispatchingStrategyRoundRobin[T any](msg T, index uint64, channels []<-chan T) int {
 	for {
 		i := int(index % uint64(len(channels)))
@@ -83,9 +84,10 @@ func DispatchingStrategyRoundRobin[T any](msg T, index uint64, channels []<-chan
 
 // DispatchingStrategyRandom distributes messages in a random manner.
 // If the channel capacity is exceeded, another random channel will be selected and so on.
+// Play: https://go.dev/play/p/GEyGn3TdGk4
 func DispatchingStrategyRandom[T any](msg T, index uint64, channels []<-chan T) int {
 	for {
-		i := rand.Intn(len(channels))
+		i := xrand.IntN(len(channels))
 		if channelIsNotFull(channels[i]) {
 			return i
 		}
@@ -94,20 +96,21 @@ func DispatchingStrategyRandom[T any](msg T, index uint64, channels []<-chan T)
 	}
 }
 
-// DispatchingStrategyRandom distributes messages in a weighted manner.
+// DispatchingStrategyWeightedRandom distributes messages in a weighted manner.
 // If the channel capacity is exceeded, another random channel will be selected and so on.
+// Play: https://go.dev/play/p/v0eMh8NZG2L
 func DispatchingStrategyWeightedRandom[T any](weights []int) DispatchingStrategy[T] {
 	seq := []int{}
 
-	for i := 0; i < len(weights); i++ {
-		for j := 0; j < weights[i]; j++ {
+	for i, weight := range weights {
+		for j := 0; j < weight; j++ {
 			seq = append(seq, i)
 		}
 	}
 
 	return func(msg T, index uint64, channels []<-chan T) int {
 		for {
-			i := seq[rand.Intn(len(seq))]
+			i := seq[xrand.IntN(len(seq))]
 			if channelIsNotFull(channels[i]) {
 				return i
 			}
@@ -119,6 +122,7 @@ func DispatchingStrategyWeightedRandom[T any](weights []int) DispatchingStrategy
 
 // DispatchingStrategyFirst distributes messages in the first non-full channel.
 // If the capacity of the first channel is exceeded, the second channel will be selected and so on.
+// Play: https://go.dev/play/p/OrJCvOmk42f
 func DispatchingStrategyFirst[T any](msg T, index uint64, channels []<-chan T) int {
 	for {
 		for i := range channels {
@@ -132,31 +136,34 @@ func DispatchingStrategyFirst[T any](msg T, index uint64, channels []<-chan T) i
 }
 
 // DispatchingStrategyLeast distributes messages in the emptiest channel.
+// Play: https://go.dev/play/p/ypy0jrRcEe7
 func DispatchingStrategyLeast[T any](msg T, index uint64, channels []<-chan T) int {
-	seq := Range(len(channels))
-
-	return MinBy(seq, func(item int, min int) bool {
-		return len(channels[item]) < len(channels[min])
+	_, i := MinIndexBy(channels, func(a, b <-chan T) bool {
+		return len(a) < len(b)
 	})
+
+	return i
 }
 
-// DispatchingStrategyMost distributes messages in the fulliest channel.
+// DispatchingStrategyMost distributes messages in the fullest channel.
 // If the channel capacity is exceeded, the next channel will be selected and so on.
+// Play: https://go.dev/play/p/erHHone7rF9
 func DispatchingStrategyMost[T any](msg T, index uint64, channels []<-chan T) int {
-	seq := Range(len(channels))
-
-	return MaxBy(seq, func(item int, max int) bool {
-		return len(channels[item]) > len(channels[max]) && channelIsNotFull(channels[item])
+	_, i := MaxIndexBy(channels, func(a, b <-chan T) bool {
+		return len(a) > len(b) && channelIsNotFull(a)
 	})
+
+	return i
 }
 
-// SliceToChannel returns a read-only channels of collection elements.
+// SliceToChannel returns a read-only channel of collection elements.
+// Play: https://go.dev/play/p/lIbSY3QmiEg
 func SliceToChannel[T any](bufferSize int, collection []T) <-chan T {
 	ch := make(chan T, bufferSize)
 
 	go func() {
-		for _, item := range collection {
-			ch <- item
+		for i := range collection {
+			ch <- collection[i]
 		}
 
 		close(ch)
@@ -165,7 +172,22 @@ func SliceToChannel[T any](bufferSize int, collection []T) <-chan T {
 	return ch
 }
 
+// ChannelToSlice returns a slice built from channel items. Blocks until channel closes.
+// Play: https://go.dev/play/p/lIbSY3QmiEg
+func ChannelToSlice[T any](ch <-chan T) []T {
+	collection := []T{}
+
+	for item := range ch {
+		collection = append(collection, item)
+	}
+
+	return collection
+}
+
 // Generator implements the generator design pattern.
+// Play: https://go.dev/play/p/lIbSY3QmiEg
+//
+// Deprecated: use "iter" package instead (Go >= 1.23).
 func Generator[T any](bufferSize int, generator func(yield func(T))) <-chan T {
 	ch := make(chan T, bufferSize)
 
@@ -181,14 +203,14 @@ func Generator[T any](bufferSize int, generator func(yield func(T))) <-chan T {
 	return ch
 }
 
-// Batch creates a slice of n elements from a channel. Returns the slice and the slice length.
-// @TODO: we should probaby provide an helper that reuse the same buffer.
-func Batch[T any](ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool) {
+// Buffer creates a slice of n elements from a channel. Returns the slice and the slice length.
+// @TODO: we should probably provide a helper that reuses the same buffer.
+// Play: https://go.dev/play/p/gPQ-6xmcKQI
+func Buffer[T any](ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool) {
 	buffer := make([]T, 0, size)
-	index := 0
 	now := time.Now()
 
-	for ; index < size; index++ {
+	for index := 0; index < size; index++ {
 		item, ok := <-ch
 		if !ok {
 			return buffer, index, time.Since(now), false
@@ -197,20 +219,17 @@ func Batch[T any](ch <-chan T, size int) (collection []T, length int, readTime t
 		buffer = append(buffer, item)
 	}
 
-	return buffer, index, time.Since(now), true
+	return buffer, size, time.Since(now), true
 }
 
-// BatchWithTimeout creates a slice of n elements from a channel, with timeout. Returns the slice and the slice length.
-// @TODO: we should probaby provide an helper that reuse the same buffer.
-func BatchWithTimeout[T any](ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool) {
-	expire := time.NewTimer(timeout)
-	defer expire.Stop()
-
+// BufferWithContext creates a slice of n elements from a channel, with context. Returns the slice and the slice length.
+// @TODO: we should probably provide a helper that reuses the same buffer.
+// Play: https://go.dev/play/p/oRfOyJWK9YF
+func BufferWithContext[T any](ctx context.Context, ch <-chan T, size int) (collection []T, length int, readTime time.Duration, ok bool) {
 	buffer := make([]T, 0, size)
-	index := 0
 	now := time.Now()
 
-	for ; index < size; index++ {
+	for index := 0; index < size; index++ {
 		select {
 		case item, ok := <-ch:
 			if !ok {
@@ -219,10 +238,67 @@ func BatchWithTimeout[T any](ch <-chan T, size int, timeout time.Duration) (coll
 
 			buffer = append(buffer, item)
 
-		case <-expire.C:
+		case <-ctx.Done():
 			return buffer, index, time.Since(now), true
 		}
 	}
 
-	return buffer, index, time.Since(now), true
+	return buffer, size, time.Since(now), true
+}
+
+// BufferWithTimeout creates a slice of n elements from a channel, with timeout. Returns the slice and the slice length.
+// Play: https://go.dev/play/p/sxyEM3koo4n
+func BufferWithTimeout[T any](ch <-chan T, size int, timeout time.Duration) (collection []T, length int, readTime time.Duration, ok bool) {
+	ctx, cancel := context.WithTimeout(context.Background(), timeout)
+	defer cancel()
+	return BufferWithContext(ctx, ch, size)
+}
+
+// FanIn collects messages from multiple input channels into a single buffered channel.
+// Output messages have no priority. When all upstream channels reach EOF, downstream channel closes.
+// Play: https://go.dev/play/p/FH8Wq-T04Jb
+func FanIn[T any](channelBufferCap int, upstreams ...<-chan T) <-chan T {
+	out := make(chan T, channelBufferCap)
+	var wg sync.WaitGroup
+
+	// Start an output goroutine for each input channel in upstreams.
+	wg.Add(len(upstreams))
+	for i := range upstreams {
+		go func(index int) {
+			for n := range upstreams[index] {
+				out <- n
+			}
+			wg.Done()
+		}(i)
+	}
+
+	// Start a goroutine to close out once all the output goroutines are done.
+	go func() {
+		wg.Wait()
+		close(out)
+	}()
+	return out
+}
+
+// FanOut broadcasts all the upstream messages to multiple downstream channels.
+// When upstream channel reaches EOF, downstream channels close. If any downstream
+// channels is full, broadcasting is paused.
+// Play: https://go.dev/play/p/2LHxcjKX23L
+func FanOut[T any](count, channelsBufferCap int, upstream <-chan T) []<-chan T {
+	downstreams := createChannels[T](count, channelsBufferCap)
+
+	go func() {
+		for msg := range upstream {
+			for i := range downstreams {
+				downstreams[i] <- msg
+			}
+		}
+
+		// Close out once all the output goroutines are done.
+		for i := range downstreams {
+			close(downstreams[i])
+		}
+	}()
+
+	return channelsToReadOnly(downstreams)
 }
diff --git a/vendor/github.com/samber/lo/concurrency.go b/vendor/github.com/samber/lo/concurrency.go
index 2d6fd871a4b..70871b286ea 100644
--- a/vendor/github.com/samber/lo/concurrency.go
+++ b/vendor/github.com/samber/lo/concurrency.go
@@ -1,21 +1,26 @@
 package lo
 
-import "sync"
+import (
+	"context"
+	"sync"
+	"time"
+)
 
 type synchronize struct {
 	locker sync.Locker
 }
 
-func (s *synchronize) Do(cb func()) {
+func (s *synchronize) Do(callback func()) {
 	s.locker.Lock()
-	Try0(cb)
+	Try0(callback)
 	s.locker.Unlock()
 }
 
 // Synchronize wraps the underlying callback in a mutex. It receives an optional mutex.
-func Synchronize(opt ...sync.Locker) *synchronize {
+// Play: https://go.dev/play/p/X3cqROSpQmu
+func Synchronize(opt ...sync.Locker) *synchronize { //nolint:revive
 	if len(opt) > 1 {
-		panic("unexpected arguments")
+		panic("lo.Synchronize: unexpected arguments")
 	} else if len(opt) == 0 {
 		opt = append(opt, &sync.Mutex{})
 	}
@@ -26,8 +31,9 @@ func Synchronize(opt ...sync.Locker) *synchronize {
 }
 
 // Async executes a function in a goroutine and returns the result in a channel.
-func Async[A any](f func() A) chan A {
-	ch := make(chan A)
+// Play: https://go.dev/play/p/uo35gosuTLw
+func Async[A any](f func() A) <-chan A {
+	ch := make(chan A, 1)
 	go func() {
 		ch <- f()
 	}()
@@ -35,8 +41,9 @@ func Async[A any](f func() A) chan A {
 }
 
 // Async0 executes a function in a goroutine and returns a channel set once the function finishes.
-func Async0(f func()) chan struct{} {
-	ch := make(chan struct{})
+// Play: https://go.dev/play/p/tNqf1cClG_o
+func Async0(f func()) <-chan struct{} {
+	ch := make(chan struct{}, 1)
 	go func() {
 		f()
 		ch <- struct{}{}
@@ -45,13 +52,15 @@ func Async0(f func()) chan struct{} {
 }
 
 // Async1 is an alias to Async.
-func Async1[A any](f func() A) chan A {
+// Play: https://go.dev/play/p/RBQWtIn4PsF
+func Async1[A any](f func() A) <-chan A {
 	return Async(f)
 }
 
 // Async2 has the same behavior as Async, but returns the 2 results as a tuple inside the channel.
-func Async2[A any, B any](f func() (A, B)) chan Tuple2[A, B] {
-	ch := make(chan Tuple2[A, B])
+// Play: https://go.dev/play/p/5SzzDjssXOH
+func Async2[A, B any](f func() (A, B)) <-chan Tuple2[A, B] {
+	ch := make(chan Tuple2[A, B], 1)
 	go func() {
 		ch <- T2(f())
 	}()
@@ -59,8 +68,9 @@ func Async2[A any, B any](f func() (A, B)) chan Tuple2[A, B] {
 }
 
 // Async3 has the same behavior as Async, but returns the 3 results as a tuple inside the channel.
-func Async3[A any, B any, C any](f func() (A, B, C)) chan Tuple3[A, B, C] {
-	ch := make(chan Tuple3[A, B, C])
+// Play: https://go.dev/play/p/cZpZsDXNmlx
+func Async3[A, B, C any](f func() (A, B, C)) <-chan Tuple3[A, B, C] {
+	ch := make(chan Tuple3[A, B, C], 1)
 	go func() {
 		ch <- T3(f())
 	}()
@@ -68,8 +78,9 @@ func Async3[A any, B any, C any](f func() (A, B, C)) chan Tuple3[A, B, C] {
 }
 
 // Async4 has the same behavior as Async, but returns the 4 results as a tuple inside the channel.
-func Async4[A any, B any, C any, D any](f func() (A, B, C, D)) chan Tuple4[A, B, C, D] {
-	ch := make(chan Tuple4[A, B, C, D])
+// Play: https://go.dev/play/p/9X5O2VrLzkR
+func Async4[A, B, C, D any](f func() (A, B, C, D)) <-chan Tuple4[A, B, C, D] {
+	ch := make(chan Tuple4[A, B, C, D], 1)
 	go func() {
 		ch <- T4(f())
 	}()
@@ -77,8 +88,9 @@ func Async4[A any, B any, C any, D any](f func() (A, B, C, D)) chan Tuple4[A, B,
 }
 
 // Async5 has the same behavior as Async, but returns the 5 results as a tuple inside the channel.
-func Async5[A any, B any, C any, D any, E any](f func() (A, B, C, D, E)) chan Tuple5[A, B, C, D, E] {
-	ch := make(chan Tuple5[A, B, C, D, E])
+// Play: https://go.dev/play/p/MqnUJpkmopA
+func Async5[A, B, C, D, E any](f func() (A, B, C, D, E)) <-chan Tuple5[A, B, C, D, E] {
+	ch := make(chan Tuple5[A, B, C, D, E], 1)
 	go func() {
 		ch <- T5(f())
 	}()
@@ -86,10 +98,50 @@ func Async5[A any, B any, C any, D any, E any](f func() (A, B, C, D, E)) chan Tu
 }
 
 // Async6 has the same behavior as Async, but returns the 6 results as a tuple inside the channel.
-func Async6[A any, B any, C any, D any, E any, F any](f func() (A, B, C, D, E, F)) chan Tuple6[A, B, C, D, E, F] {
-	ch := make(chan Tuple6[A, B, C, D, E, F])
+// Play: https://go.dev/play/p/kM1X67JPdSP
+func Async6[A, B, C, D, E, F any](f func() (A, B, C, D, E, F)) <-chan Tuple6[A, B, C, D, E, F] {
+	ch := make(chan Tuple6[A, B, C, D, E, F], 1)
 	go func() {
 		ch <- T6(f())
 	}()
 	return ch
 }
+
+// WaitFor runs periodically until a condition is validated.
+// Play: https://go.dev/play/p/t_wTDmubbK3
+func WaitFor(condition func(i int) bool, timeout, heartbeatDelay time.Duration) (totalIterations int, elapsed time.Duration, conditionFound bool) {
+	conditionWithContext := func(_ context.Context, currentIteration int) bool {
+		return condition(currentIteration)
+	}
+	return WaitForWithContext(context.Background(), conditionWithContext, timeout, heartbeatDelay)
+}
+
+// WaitForWithContext runs periodically until a condition is validated or context is canceled.
+// Play: https://go.dev/play/p/t_wTDmubbK3
+func WaitForWithContext(ctx context.Context, condition func(ctx context.Context, currentIteration int) bool, timeout, heartbeatDelay time.Duration) (totalIterations int, elapsed time.Duration, conditionFound bool) {
+	start := time.Now()
+
+	if ctx.Err() != nil {
+		return totalIterations, time.Since(start), false
+	}
+
+	ctx, cleanCtx := context.WithTimeout(ctx, timeout)
+	ticker := time.NewTicker(heartbeatDelay)
+
+	defer func() {
+		cleanCtx()
+		ticker.Stop()
+	}()
+
+	for {
+		select {
+		case <-ctx.Done():
+			return totalIterations, time.Since(start), false
+		case <-ticker.C:
+			totalIterations++
+			if condition(ctx, totalIterations-1) {
+				return totalIterations, time.Since(start), true
+			}
+		}
+	}
+}
diff --git a/vendor/github.com/samber/lo/condition.go b/vendor/github.com/samber/lo/condition.go
index 1d4e75d25ed..92ed36b0dac 100644
--- a/vendor/github.com/samber/lo/condition.go
+++ b/vendor/github.com/samber/lo/condition.go
@@ -1,8 +1,9 @@
 package lo
 
-// Ternary is a 1 line if/else statement.
+// Ternary is a single line if/else statement.
+// Take care to avoid dereferencing potentially nil pointers in your A/B expressions, because they are both evaluated. See TernaryF to avoid this problem.
 // Play: https://go.dev/play/p/t-D7WBL44h2
-func Ternary[T any](condition bool, ifOutput T, elseOutput T) T {
+func Ternary[T any](condition bool, ifOutput, elseOutput T) T {
 	if condition {
 		return ifOutput
 	}
@@ -10,9 +11,9 @@ func Ternary[T any](condition bool, ifOutput T, elseOutput T) T {
 	return elseOutput
 }
 
-// TernaryF is a 1 line if/else statement whose options are functions
+// TernaryF is a single line if/else statement whose options are functions.
 // Play: https://go.dev/play/p/AO4VW20JoqM
-func TernaryF[T any](condition bool, ifFunc func() T, elseFunc func() T) T {
+func TernaryF[T any](condition bool, ifFunc, elseFunc func() T) T {
 	if condition {
 		return ifFunc()
 	}
@@ -25,9 +26,9 @@ type ifElse[T any] struct {
 	done   bool
 }
 
-// If.
+// If is a single line if/else statement.
 // Play: https://go.dev/play/p/WSw3ApMxhyW
-func If[T any](condition bool, result T) *ifElse[T] {
+func If[T any](condition bool, result T) *ifElse[T] { //nolint:revive
 	if condition {
 		return &ifElse[T]{result, true}
 	}
@@ -36,9 +37,9 @@ func If[T any](condition bool, result T) *ifElse[T] {
 	return &ifElse[T]{t, false}
 }
 
-// IfF.
+// IfF is a single line if/else statement whose options are functions.
 // Play: https://go.dev/play/p/WSw3ApMxhyW
-func IfF[T any](condition bool, resultF func() T) *ifElse[T] {
+func IfF[T any](condition bool, resultF func() T) *ifElse[T] { //nolint:revive
 	if condition {
 		return &ifElse[T]{resultF(), true}
 	}
@@ -97,7 +98,7 @@ type switchCase[T comparable, R any] struct {
 
 // Switch is a pure functional switch/case/default statement.
 // Play: https://go.dev/play/p/TGbKUMAeRUd
-func Switch[T comparable, R any](predicate T) *switchCase[T, R] {
+func Switch[T comparable, R any](predicate T) *switchCase[T, R] { //nolint:revive
 	var result R
 
 	return &switchCase[T, R]{
@@ -120,9 +121,9 @@ func (s *switchCase[T, R]) Case(val T, result R) *switchCase[T, R] {
 
 // CaseF.
 // Play: https://go.dev/play/p/TGbKUMAeRUd
-func (s *switchCase[T, R]) CaseF(val T, cb func() R) *switchCase[T, R] {
+func (s *switchCase[T, R]) CaseF(val T, callback func() R) *switchCase[T, R] {
 	if !s.done && s.predicate == val {
-		s.result = cb()
+		s.result = callback()
 		s.done = true
 	}
 
@@ -141,9 +142,9 @@ func (s *switchCase[T, R]) Default(result R) R {
 
 // DefaultF.
 // Play: https://go.dev/play/p/TGbKUMAeRUd
-func (s *switchCase[T, R]) DefaultF(cb func() R) R {
+func (s *switchCase[T, R]) DefaultF(callback func() R) R {
 	if !s.done {
-		s.result = cb()
+		s.result = callback()
 	}
 
 	return s.result
diff --git a/vendor/github.com/samber/lo/docker-compose.yml b/vendor/github.com/samber/lo/docker-compose.yml
deleted file mode 100644
index 511e85fde26..00000000000
--- a/vendor/github.com/samber/lo/docker-compose.yml
+++ /dev/null
@@ -1,9 +0,0 @@
-version: '3'
-
-services:
-  dev:
-    image: golang:1.18-bullseye
-    volumes:
-      - ./:/go/src/github.com/samber/lo
-    working_dir: /go/src/github.com/samber/lo
-    command: make watch-test
diff --git a/vendor/github.com/samber/lo/errors.go b/vendor/github.com/samber/lo/errors.go
index 0a4cb5b8555..8313edd7aea 100644
--- a/vendor/github.com/samber/lo/errors.go
+++ b/vendor/github.com/samber/lo/errors.go
@@ -6,16 +6,18 @@ import (
 	"reflect"
 )
 
+const defaultAssertionFailureMessage = "assertion failed"
+
 // Validate is a helper that creates an error when a condition is not met.
 // Play: https://go.dev/play/p/vPyh51XpCBt
 func Validate(ok bool, format string, args ...any) error {
 	if !ok {
-		return fmt.Errorf(fmt.Sprintf(format, args...))
+		return fmt.Errorf(format, args...)
 	}
 	return nil
 }
 
-func messageFromMsgAndArgs(msgAndArgs ...interface{}) string {
+func messageFromMsgAndArgs(msgAndArgs ...any) string {
 	if len(msgAndArgs) == 1 {
 		if msgAsStr, ok := msgAndArgs[0].(string); ok {
 			return msgAsStr
@@ -23,13 +25,13 @@ func messageFromMsgAndArgs(msgAndArgs ...interface{}) string {
 		return fmt.Sprintf("%+v", msgAndArgs[0])
 	}
 	if len(msgAndArgs) > 1 {
-		return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...)
+		return fmt.Sprintf(msgAndArgs[0].(string), msgAndArgs[1:]...) //nolint:errcheck,forcetypeassert
 	}
 	return ""
 }
 
-// must panics if err is error or false.
-func must(err any, messageArgs ...interface{}) {
+// MustChecker panics if err is error or false.
+var MustChecker = func(err any, messageArgs ...any) {
 	if err == nil {
 		return
 	}
@@ -49,9 +51,8 @@ func must(err any, messageArgs ...interface{}) {
 		message := messageFromMsgAndArgs(messageArgs...)
 		if message != "" {
 			panic(message + ": " + e.Error())
-		} else {
-			panic(e.Error())
 		}
+		panic(e.Error())
 
 	default:
 		panic("must: invalid err type '" + reflect.TypeOf(err).Name() + "', should either be a bool or an error")
@@ -60,56 +61,56 @@ func must(err any, messageArgs ...interface{}) {
 
 // Must is a helper that wraps a call to a function returning a value and an error
 // and panics if err is error or false.
-// Play: https://go.dev/play/p/TMoWrRp3DyC
-func Must[T any](val T, err any, messageArgs ...interface{}) T {
-	must(err, messageArgs...)
+// Play: https://go.dev/play/p/fOqtX5HudtN
+func Must[T any](val T, err any, messageArgs ...any) T {
+	MustChecker(err, messageArgs...)
 	return val
 }
 
-// Must0 has the same behavior than Must, but callback returns no variable.
+// Must0 has the same behavior as Must, but callback returns no variable.
 // Play: https://go.dev/play/p/TMoWrRp3DyC
-func Must0(err any, messageArgs ...interface{}) {
-	must(err, messageArgs...)
+func Must0(err any, messageArgs ...any) {
+	MustChecker(err, messageArgs...)
 }
 
-// Must1 is an alias to Must
+// Must1 is an alias to Must.
 // Play: https://go.dev/play/p/TMoWrRp3DyC
-func Must1[T any](val T, err any, messageArgs ...interface{}) T {
+func Must1[T any](val T, err any, messageArgs ...any) T {
 	return Must(val, err, messageArgs...)
 }
 
-// Must2 has the same behavior than Must, but callback returns 2 variables.
+// Must2 has the same behavior as Must, but callback returns 2 variables.
 // Play: https://go.dev/play/p/TMoWrRp3DyC
-func Must2[T1 any, T2 any](val1 T1, val2 T2, err any, messageArgs ...interface{}) (T1, T2) {
-	must(err, messageArgs...)
+func Must2[T1, T2 any](val1 T1, val2 T2, err any, messageArgs ...any) (T1, T2) {
+	MustChecker(err, messageArgs...)
 	return val1, val2
 }
 
-// Must3 has the same behavior than Must, but callback returns 3 variables.
+// Must3 has the same behavior as Must, but callback returns 3 variables.
 // Play: https://go.dev/play/p/TMoWrRp3DyC
-func Must3[T1 any, T2 any, T3 any](val1 T1, val2 T2, val3 T3, err any, messageArgs ...interface{}) (T1, T2, T3) {
-	must(err, messageArgs...)
+func Must3[T1, T2, T3 any](val1 T1, val2 T2, val3 T3, err any, messageArgs ...any) (T1, T2, T3) {
+	MustChecker(err, messageArgs...)
 	return val1, val2, val3
 }
 
-// Must4 has the same behavior than Must, but callback returns 4 variables.
+// Must4 has the same behavior as Must, but callback returns 4 variables.
 // Play: https://go.dev/play/p/TMoWrRp3DyC
-func Must4[T1 any, T2 any, T3 any, T4 any](val1 T1, val2 T2, val3 T3, val4 T4, err any, messageArgs ...interface{}) (T1, T2, T3, T4) {
-	must(err, messageArgs...)
+func Must4[T1, T2, T3, T4 any](val1 T1, val2 T2, val3 T3, val4 T4, err any, messageArgs ...any) (T1, T2, T3, T4) {
+	MustChecker(err, messageArgs...)
 	return val1, val2, val3, val4
 }
 
-// Must5 has the same behavior than Must, but callback returns 5 variables.
+// Must5 has the same behavior as Must, but callback returns 5 variables.
 // Play: https://go.dev/play/p/TMoWrRp3DyC
-func Must5[T1 any, T2 any, T3 any, T4 any, T5 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, err any, messageArgs ...interface{}) (T1, T2, T3, T4, T5) {
-	must(err, messageArgs...)
+func Must5[T1, T2, T3, T4, T5 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, err any, messageArgs ...any) (T1, T2, T3, T4, T5) {
+	MustChecker(err, messageArgs...)
 	return val1, val2, val3, val4, val5
 }
 
-// Must6 has the same behavior than Must, but callback returns 6 variables.
+// Must6 has the same behavior as Must, but callback returns 6 variables.
 // Play: https://go.dev/play/p/TMoWrRp3DyC
-func Must6[T1 any, T2 any, T3 any, T4 any, T5 any, T6 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, val6 T6, err any, messageArgs ...interface{}) (T1, T2, T3, T4, T5, T6) {
-	must(err, messageArgs...)
+func Must6[T1, T2, T3, T4, T5, T6 any](val1 T1, val2 T2, val3 T3, val4 T4, val5 T5, val6 T6, err any, messageArgs ...any) (T1, T2, T3, T4, T5, T6) {
+	MustChecker(err, messageArgs...)
 	return val1, val2, val3, val4, val5, val6
 }
 
@@ -128,10 +129,10 @@ func Try(callback func() error) (ok bool) {
 		ok = false
 	}
 
-	return
+	return ok
 }
 
-// Try0 has the same behavior than Try, but callback returns no variable.
+// Try0 has the same behavior as Try, but callback returns no variable.
 // Play: https://go.dev/play/p/mTyyWUvn9u4
 func Try0(callback func()) bool {
 	return Try(func() error {
@@ -146,7 +147,7 @@ func Try1(callback func() error) bool {
 	return Try(callback)
 }
 
-// Try2 has the same behavior than Try, but callback returns 2 variables.
+// Try2 has the same behavior as Try, but callback returns 2 variables.
 // Play: https://go.dev/play/p/mTyyWUvn9u4
 func Try2[T any](callback func() (T, error)) bool {
 	return Try(func() error {
@@ -155,7 +156,7 @@ func Try2[T any](callback func() (T, error)) bool {
 	})
 }
 
-// Try3 has the same behavior than Try, but callback returns 3 variables.
+// Try3 has the same behavior as Try, but callback returns 3 variables.
 // Play: https://go.dev/play/p/mTyyWUvn9u4
 func Try3[T, R any](callback func() (T, R, error)) bool {
 	return Try(func() error {
@@ -164,7 +165,7 @@ func Try3[T, R any](callback func() (T, R, error)) bool {
 	})
 }
 
-// Try4 has the same behavior than Try, but callback returns 4 variables.
+// Try4 has the same behavior as Try, but callback returns 4 variables.
 // Play: https://go.dev/play/p/mTyyWUvn9u4
 func Try4[T, R, S any](callback func() (T, R, S, error)) bool {
 	return Try(func() error {
@@ -173,7 +174,7 @@ func Try4[T, R, S any](callback func() (T, R, S, error)) bool {
 	})
 }
 
-// Try5 has the same behavior than Try, but callback returns 5 variables.
+// Try5 has the same behavior as Try, but callback returns 5 variables.
 // Play: https://go.dev/play/p/mTyyWUvn9u4
 func Try5[T, R, S, Q any](callback func() (T, R, S, Q, error)) bool {
 	return Try(func() error {
@@ -182,7 +183,7 @@ func Try5[T, R, S, Q any](callback func() (T, R, S, Q, error)) bool {
 	})
 }
 
-// Try6 has the same behavior than Try, but callback returns 6 variables.
+// Try6 has the same behavior as Try, but callback returns 6 variables.
 // Play: https://go.dev/play/p/mTyyWUvn9u4
 func Try6[T, R, S, Q, U any](callback func() (T, R, S, Q, U, error)) bool {
 	return Try(func() error {
@@ -191,13 +192,13 @@ func Try6[T, R, S, Q, U any](callback func() (T, R, S, Q, U, error)) bool {
 	})
 }
 
-// TryOr has the same behavior than Must, but returns a default value in case of error.
+// TryOr has the same behavior as Must, but returns a default value in case of error.
 // Play: https://go.dev/play/p/B4F7Wg2Zh9X
 func TryOr[A any](callback func() (A, error), fallbackA A) (A, bool) {
 	return TryOr1(callback, fallbackA)
 }
 
-// TryOr1 has the same behavior than Must, but returns a default value in case of error.
+// TryOr1 has the same behavior as Must, but returns a default value in case of error.
 // Play: https://go.dev/play/p/B4F7Wg2Zh9X
 func TryOr1[A any](callback func() (A, error), fallbackA A) (A, bool) {
 	ok := false
@@ -213,9 +214,9 @@ func TryOr1[A any](callback func() (A, error), fallbackA A) (A, bool) {
 	return fallbackA, ok
 }
 
-// TryOr2 has the same behavior than Must, but returns a default value in case of error.
+// TryOr2 has the same behavior as Must, but returns a default value in case of error.
 // Play: https://go.dev/play/p/B4F7Wg2Zh9X
-func TryOr2[A any, B any](callback func() (A, B, error), fallbackA A, fallbackB B) (A, B, bool) {
+func TryOr2[A, B any](callback func() (A, B, error), fallbackA A, fallbackB B) (A, B, bool) {
 	ok := false
 
 	Try0(func() {
@@ -230,9 +231,9 @@ func TryOr2[A any, B any](callback func() (A, B, error), fallbackA A, fallbackB
 	return fallbackA, fallbackB, ok
 }
 
-// TryOr3 has the same behavior than Must, but returns a default value in case of error.
+// TryOr3 has the same behavior as Must, but returns a default value in case of error.
 // Play: https://go.dev/play/p/B4F7Wg2Zh9X
-func TryOr3[A any, B any, C any](callback func() (A, B, C, error), fallbackA A, fallbackB B, fallbackC C) (A, B, C, bool) {
+func TryOr3[A, B, C any](callback func() (A, B, C, error), fallbackA A, fallbackB B, fallbackC C) (A, B, C, bool) {
 	ok := false
 
 	Try0(func() {
@@ -248,9 +249,9 @@ func TryOr3[A any, B any, C any](callback func() (A, B, C, error), fallbackA A,
 	return fallbackA, fallbackB, fallbackC, ok
 }
 
-// TryOr4 has the same behavior than Must, but returns a default value in case of error.
+// TryOr4 has the same behavior as Must, but returns a default value in case of error.
 // Play: https://go.dev/play/p/B4F7Wg2Zh9X
-func TryOr4[A any, B any, C any, D any](callback func() (A, B, C, D, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D) (A, B, C, D, bool) {
+func TryOr4[A, B, C, D any](callback func() (A, B, C, D, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D) (A, B, C, D, bool) {
 	ok := false
 
 	Try0(func() {
@@ -267,9 +268,9 @@ func TryOr4[A any, B any, C any, D any](callback func() (A, B, C, D, error), fal
 	return fallbackA, fallbackB, fallbackC, fallbackD, ok
 }
 
-// TryOr5 has the same behavior than Must, but returns a default value in case of error.
+// TryOr5 has the same behavior as Must, but returns a default value in case of error.
 // Play: https://go.dev/play/p/B4F7Wg2Zh9X
-func TryOr5[A any, B any, C any, D any, E any](callback func() (A, B, C, D, E, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D, fallbackE E) (A, B, C, D, E, bool) {
+func TryOr5[A, B, C, D, E any](callback func() (A, B, C, D, E, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D, fallbackE E) (A, B, C, D, E, bool) {
 	ok := false
 
 	Try0(func() {
@@ -287,9 +288,9 @@ func TryOr5[A any, B any, C any, D any, E any](callback func() (A, B, C, D, E, e
 	return fallbackA, fallbackB, fallbackC, fallbackD, fallbackE, ok
 }
 
-// TryOr6 has the same behavior than Must, but returns a default value in case of error.
+// TryOr6 has the same behavior as Must, but returns a default value in case of error.
 // Play: https://go.dev/play/p/B4F7Wg2Zh9X
-func TryOr6[A any, B any, C any, D any, E any, F any](callback func() (A, B, C, D, E, F, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D, fallbackE E, fallbackF F) (A, B, C, D, E, F, bool) {
+func TryOr6[A, B, C, D, E, F any](callback func() (A, B, C, D, E, F, error), fallbackA A, fallbackB B, fallbackC C, fallbackD D, fallbackE E, fallbackF F) (A, B, C, D, E, F, bool) {
 	ok := false
 
 	Try0(func() {
@@ -308,7 +309,7 @@ func TryOr6[A any, B any, C any, D any, E any, F any](callback func() (A, B, C,
 	return fallbackA, fallbackB, fallbackC, fallbackD, fallbackE, fallbackF, ok
 }
 
-// TryWithErrorValue has the same behavior than Try, but also returns value passed to panic.
+// TryWithErrorValue has the same behavior as Try, but also returns value passed to panic.
 // Play: https://go.dev/play/p/Kc7afQIT2Fs
 func TryWithErrorValue(callback func() error) (errorValue any, ok bool) {
 	ok = true
@@ -326,10 +327,10 @@ func TryWithErrorValue(callback func() error) (errorValue any, ok bool) {
 		errorValue = err
 	}
 
-	return
+	return errorValue, ok
 }
 
-// TryCatch has the same behavior than Try, but calls the catch function in case of error.
+// TryCatch has the same behavior as Try, but calls the catch function in case of error.
 // Play: https://go.dev/play/p/PnOON-EqBiU
 func TryCatch(callback func() error, catch func()) {
 	if !Try(callback) {
@@ -337,7 +338,7 @@ func TryCatch(callback func() error, catch func()) {
 	}
 }
 
-// TryCatchWithErrorValue has the same behavior than TryWithErrorValue, but calls the catch function in case of error.
+// TryCatchWithErrorValue has the same behavior as TryWithErrorValue, but calls the catch function in case of error.
 // Play: https://go.dev/play/p/8Pc9gwX_GZO
 func TryCatchWithErrorValue(callback func() error, catch func(any)) {
 	if err, ok := TryWithErrorValue(callback); !ok {
@@ -352,3 +353,28 @@ func ErrorsAs[T error](err error) (T, bool) {
 	ok := errors.As(err, &t)
 	return t, ok
 }
+
+// Assert does nothing when the condition is true, otherwise it panics with an optional message.
+// Play: https://go.dev/play/p/Xv8LLKBMNwI
+var Assert = func(condition bool, message ...string) {
+	if condition {
+		return
+	}
+
+	panicMessage := defaultAssertionFailureMessage
+	if len(message) > 0 {
+		panicMessage = fmt.Sprintf("%s: %s", defaultAssertionFailureMessage, message[0])
+	}
+	panic(panicMessage)
+}
+
+// Assertf does nothing when the condition is true, otherwise it panics with a formatted message.
+// Play: https://go.dev/play/p/TVPEmVcyrdY
+var Assertf = func(condition bool, format string, args ...any) {
+	if condition {
+		return
+	}
+
+	panicMessage := fmt.Sprintf("%s: %s", defaultAssertionFailureMessage, fmt.Sprintf(format, args...))
+	panic(panicMessage)
+}
diff --git a/vendor/github.com/samber/lo/find.go b/vendor/github.com/samber/lo/find.go
index e40bfcc8737..f5be8520c4a 100644
--- a/vendor/github.com/samber/lo/find.go
+++ b/vendor/github.com/samber/lo/find.go
@@ -1,19 +1,18 @@
 package lo
 
 import (
-	"fmt"
-	"math/rand"
+	"time"
 
-	"golang.org/x/exp/constraints"
+	"github.com/samber/lo/internal/constraints"
+	"github.com/samber/lo/internal/xrand"
 )
 
-// import "golang.org/x/exp/constraints"
-
-// IndexOf returns the index at which the first occurrence of a value is found in an array or return -1
+// IndexOf returns the index at which the first occurrence of a value is found in a slice or -1
 // if the value cannot be found.
+// Play: https://go.dev/play/p/Eo7W0lvKTky
 func IndexOf[T comparable](collection []T, element T) int {
-	for i, item := range collection {
-		if item == element {
+	for i := range collection {
+		if collection[i] == element {
 			return i
 		}
 	}
@@ -21,8 +20,9 @@ func IndexOf[T comparable](collection []T, element T) int {
 	return -1
 }
 
-// LastIndexOf returns the index at which the last occurrence of a value is found in an array or return -1
+// LastIndexOf returns the index at which the last occurrence of a value is found in a slice or -1
 // if the value cannot be found.
+// Play: https://go.dev/play/p/Eo7W0lvKTky
 func LastIndexOf[T comparable](collection []T, element T) int {
 	length := len(collection)
 
@@ -35,11 +35,44 @@ func LastIndexOf[T comparable](collection []T, element T) int {
 	return -1
 }
 
-// Find search an element in a slice based on a predicate. It returns element and true if element was found.
-func Find[T any](collection []T, predicate func(T) bool) (T, bool) {
-	for _, item := range collection {
-		if predicate(item) {
-			return item, true
+// HasPrefix returns true if the collection has the prefix.
+// Play: https://go.dev/play/p/SrljzVDpMQM
+func HasPrefix[T comparable](collection, prefix []T) bool {
+	if len(collection) < len(prefix) {
+		return false
+	}
+
+	for i := range prefix {
+		if collection[i] != prefix[i] {
+			return false
+		}
+	}
+
+	return true
+}
+
+// HasSuffix returns true if the collection has the suffix.
+// Play: https://go.dev/play/p/bJeLetQNAON
+func HasSuffix[T comparable](collection, suffix []T) bool {
+	if len(collection) < len(suffix) {
+		return false
+	}
+
+	for i := range suffix {
+		if collection[len(collection)-len(suffix)+i] != suffix[i] {
+			return false
+		}
+	}
+
+	return true
+}
+
+// Find searches for an element in a slice based on a predicate. Returns element and true if element was found.
+// Play: https://go.dev/play/p/Eo7W0lvKTky
+func Find[T any](collection []T, predicate func(item T) bool) (T, bool) {
+	for i := range collection {
+		if predicate(collection[i]) {
+			return collection[i], true
 		}
 	}
 
@@ -47,12 +80,33 @@ func Find[T any](collection []T, predicate func(T) bool) (T, bool) {
 	return result, false
 }
 
-// FindIndexOf searches an element in a slice based on a predicate and returns the index and true.
-// It returns -1 and false if the element is not found.
-func FindIndexOf[T any](collection []T, predicate func(T) bool) (T, int, bool) {
-	for i, item := range collection {
-		if predicate(item) {
-			return item, i, true
+// FindErr searches for an element in a slice based on a predicate that can return an error.
+// Returns the element and nil error if the element is found.
+// Returns zero value and nil error if the element is not found.
+// If the predicate returns an error, iteration stops immediately and returns zero value and the error.
+func FindErr[T any](collection []T, predicate func(item T) (bool, error)) (T, error) {
+	for i := range collection {
+		matches, err := predicate(collection[i])
+		if err != nil {
+			var result T
+			return result, err
+		}
+		if matches {
+			return collection[i], nil
+		}
+	}
+
+	var result T
+	return result, nil
+}
+
+// FindIndexOf searches for an element in a slice based on a predicate and returns the index and true.
+// Returns -1 and false if the element is not found.
+// Play: https://go.dev/play/p/XWSEM4Ic_t0
+func FindIndexOf[T any](collection []T, predicate func(item T) bool) (T, int, bool) {
+	for i := range collection {
+		if predicate(collection[i]) {
+			return collection[i], i, true
 		}
 	}
 
@@ -60,9 +114,10 @@ func FindIndexOf[T any](collection []T, predicate func(T) bool) (T, int, bool) {
 	return result, -1, false
 }
 
-// FindLastIndexOf searches last element in a slice based on a predicate and returns the index and true.
-// It returns -1 and false if the element is not found.
-func FindLastIndexOf[T any](collection []T, predicate func(T) bool) (T, int, bool) {
+// FindLastIndexOf searches for the last element in a slice based on a predicate and returns the index and true.
+// Returns -1 and false if the element is not found.
+// Play: https://go.dev/play/p/dPiMRtJ6cUx
+func FindLastIndexOf[T any](collection []T, predicate func(item T) bool) (T, int, bool) {
 	length := len(collection)
 
 	for i := length - 1; i >= 0; i-- {
@@ -75,11 +130,12 @@ func FindLastIndexOf[T any](collection []T, predicate func(T) bool) (T, int, boo
 	return result, -1, false
 }
 
-// FindOrElse search an element in a slice based on a predicate. It returns the element if found or a given fallback value otherwise.
-func FindOrElse[T any](collection []T, fallback T, predicate func(T) bool) T {
-	for _, item := range collection {
-		if predicate(item) {
-			return item
+// FindOrElse searches for an element in a slice based on a predicate. Returns the element if found or a given fallback value otherwise.
+// Play: https://go.dev/play/p/Eo7W0lvKTky
+func FindOrElse[T any](collection []T, fallback T, predicate func(item T) bool) T {
+	for i := range collection {
+		if predicate(collection[i]) {
+			return collection[i]
 		}
 	}
 
@@ -87,7 +143,8 @@ func FindOrElse[T any](collection []T, fallback T, predicate func(T) bool) T {
 }
 
 // FindKey returns the key of the first value matching.
-func FindKey[K comparable, V comparable](object map[K]V, value V) (K, bool) {
+// Play: https://go.dev/play/p/Bg0w1VDPYXx
+func FindKey[K, V comparable](object map[K]V, value V) (K, bool) {
 	for k, v := range object {
 		if v == value {
 			return k, true
@@ -97,8 +154,9 @@ func FindKey[K comparable, V comparable](object map[K]V, value V) (K, bool) {
 	return Empty[K](), false
 }
 
-// FindKeyBy returns the key of the first element predicate returns truthy for.
-func FindKeyBy[K comparable, V any](object map[K]V, predicate func(K, V) bool) (K, bool) {
+// FindKeyBy returns the key of the first element predicate returns true for.
+// Play: https://go.dev/play/p/9IbiPElcyo8
+func FindKeyBy[K comparable, V any](object map[K]V, predicate func(key K, value V) bool) (K, bool) {
 	for k, v := range object {
 		if predicate(k, v) {
 			return k, true
@@ -108,111 +166,127 @@ func FindKeyBy[K comparable, V any](object map[K]V, predicate func(K, V) bool) (
 	return Empty[K](), false
 }
 
-// FindUniques returns a slice with all the unique elements of the collection.
+// FindUniques returns a slice with all the elements that appear in the collection only once.
 // The order of result values is determined by the order they occur in the collection.
-func FindUniques[T comparable](collection []T) []T {
+func FindUniques[T comparable, Slice ~[]T](collection Slice) Slice {
 	isDupl := make(map[T]bool, len(collection))
 
-	for _, item := range collection {
-		duplicated, ok := isDupl[item]
-		if !ok {
-			isDupl[item] = false
-		} else if !duplicated {
-			isDupl[item] = true
+	duplicates := 0
+
+	for i := range collection {
+		duplicated, seen := isDupl[collection[i]]
+		if !duplicated {
+			isDupl[collection[i]] = seen
+
+			if seen {
+				duplicates++
+			}
 		}
 	}
 
-	result := make([]T, 0, len(collection)-len(isDupl))
+	result := make(Slice, 0, len(isDupl)-duplicates)
 
-	for _, item := range collection {
-		if duplicated := isDupl[item]; !duplicated {
-			result = append(result, item)
+	for i := range collection {
+		if duplicated := isDupl[collection[i]]; !duplicated {
+			result = append(result, collection[i])
 		}
 	}
 
 	return result
 }
 
-// FindUniquesBy returns a slice with all the unique elements of the collection.
-// The order of result values is determined by the order they occur in the array. It accepts `iteratee` which is
-// invoked for each element in array to generate the criterion by which uniqueness is computed.
-func FindUniquesBy[T any, U comparable](collection []T, iteratee func(T) U) []T {
+// FindUniquesBy returns a slice with all the elements that appear in the collection only once.
+// The order of result values is determined by the order they occur in the slice. It accepts `iteratee` which is
+// invoked for each element in the slice to generate the criterion by which uniqueness is computed.
+func FindUniquesBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice {
 	isDupl := make(map[U]bool, len(collection))
 
-	for _, item := range collection {
-		key := iteratee(item)
+	duplicates := 0
 
-		duplicated, ok := isDupl[key]
-		if !ok {
-			isDupl[key] = false
-		} else if !duplicated {
-			isDupl[key] = true
+	for i := range collection {
+		key := iteratee(collection[i])
+
+		duplicated, seen := isDupl[key]
+		if !duplicated {
+			isDupl[key] = seen
+
+			if seen {
+				duplicates++
+			}
 		}
 	}
 
-	result := make([]T, 0, len(collection)-len(isDupl))
+	result := make(Slice, 0, len(isDupl)-duplicates)
 
-	for _, item := range collection {
-		key := iteratee(item)
+	for i := range collection {
+		key := iteratee(collection[i])
 
 		if duplicated := isDupl[key]; !duplicated {
-			result = append(result, item)
+			result = append(result, collection[i])
 		}
 	}
 
 	return result
 }
 
-// FindDuplicates returns a slice with the first occurence of each duplicated elements of the collection.
+// FindDuplicates returns a slice with the first occurrence of each duplicated element in the collection.
 // The order of result values is determined by the order they occur in the collection.
-func FindDuplicates[T comparable](collection []T) []T {
+func FindDuplicates[T comparable, Slice ~[]T](collection Slice) Slice {
 	isDupl := make(map[T]bool, len(collection))
 
-	for _, item := range collection {
-		duplicated, ok := isDupl[item]
-		if !ok {
-			isDupl[item] = false
-		} else if !duplicated {
-			isDupl[item] = true
+	duplicates := 0
+
+	for i := range collection {
+		duplicated, seen := isDupl[collection[i]]
+		if !duplicated {
+			isDupl[collection[i]] = seen
+
+			if seen {
+				duplicates++
+			}
 		}
 	}
 
-	result := make([]T, 0, len(collection)-len(isDupl))
+	result := make(Slice, 0, duplicates)
 
-	for _, item := range collection {
-		if duplicated := isDupl[item]; duplicated {
-			result = append(result, item)
-			isDupl[item] = false
+	for i := range collection {
+		if duplicated := isDupl[collection[i]]; duplicated {
+			result = append(result, collection[i])
+			isDupl[collection[i]] = false
 		}
 	}
 
 	return result
 }
 
-// FindDuplicatesBy returns a slice with the first occurence of each duplicated elements of the collection.
-// The order of result values is determined by the order they occur in the array. It accepts `iteratee` which is
-// invoked for each element in array to generate the criterion by which uniqueness is computed.
-func FindDuplicatesBy[T any, U comparable](collection []T, iteratee func(T) U) []T {
+// FindDuplicatesBy returns a slice with the first occurrence of each duplicated element in the collection.
+// The order of result values is determined by the order they occur in the slice. It accepts `iteratee` which is
+// invoked for each element in the slice to generate the criterion by which uniqueness is computed.
+func FindDuplicatesBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice {
 	isDupl := make(map[U]bool, len(collection))
 
-	for _, item := range collection {
-		key := iteratee(item)
+	duplicates := 0
 
-		duplicated, ok := isDupl[key]
-		if !ok {
-			isDupl[key] = false
-		} else if !duplicated {
-			isDupl[key] = true
+	for i := range collection {
+		key := iteratee(collection[i])
+
+		duplicated, seen := isDupl[key]
+		if !duplicated {
+			isDupl[key] = seen
+
+			if seen {
+				duplicates++
+			}
 		}
 	}
 
-	result := make([]T, 0, len(collection)-len(isDupl))
+	result := make(Slice, 0, duplicates)
 
-	for _, item := range collection {
-		key := iteratee(item)
+	for i := range collection {
+		key := iteratee(collection[i])
 
 		if duplicated := isDupl[key]; duplicated {
-			result = append(result, item)
+			result = append(result, collection[i])
 			isDupl[key] = false
 		}
 	}
@@ -220,148 +294,701 @@ func FindDuplicatesBy[T any, U comparable](collection []T, iteratee func(T) U) [
 	return result
 }
 
+// FindDuplicatesByErr returns a slice with the first occurrence of each duplicated element in the collection.
+// The order of result values is determined by the order they occur in the slice. It accepts `iteratee` which is
+// invoked for each element in the slice to generate the criterion by which uniqueness is computed.
+// If the iteratee returns an error, iteration stops immediately and the error is returned with a nil slice.
+func FindDuplicatesByErr[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) (U, error)) (Slice, error) {
+	isDupl := make(map[U]bool, len(collection))
+
+	duplicates := 0
+
+	// First pass: identify duplicates
+	for i := range collection {
+		key, err := iteratee(collection[i])
+		if err != nil {
+			var result Slice
+			return result, err
+		}
+
+		duplicated, seen := isDupl[key]
+		if !duplicated {
+			isDupl[key] = seen
+
+			if seen {
+				duplicates++
+			}
+		}
+	}
+
+	result := make(Slice, 0, duplicates)
+
+	// Second pass: collect first occurrences of duplicates
+	for i := range collection {
+		key, err := iteratee(collection[i])
+		if err != nil {
+			var result Slice
+			return result, err
+		}
+
+		if duplicated := isDupl[key]; duplicated {
+			result = append(result, collection[i])
+			isDupl[key] = false
+		}
+	}
+
+	return result, nil
+}
+
 // Min search the minimum value of a collection.
+// Returns zero value when the collection is empty.
+// Play: https://go.dev/play/p/r6e-Z8JozS8
 func Min[T constraints.Ordered](collection []T) T {
-	var min T
+	var mIn T
 
 	if len(collection) == 0 {
-		return min
+		return mIn
 	}
 
-	min = collection[0]
+	mIn = collection[0]
 
 	for i := 1; i < len(collection); i++ {
 		item := collection[i]
 
-		if item < min {
-			min = item
+		if item < mIn {
+			mIn = item
 		}
 	}
 
-	return min
+	return mIn
+}
+
+// MinIndex search the minimum value of a collection and the index of the minimum value.
+// Returns (zero value, -1) when the collection is empty.
+func MinIndex[T constraints.Ordered](collection []T) (T, int) {
+	var (
+		mIn   T
+		index int
+	)
+
+	if len(collection) == 0 {
+		return mIn, -1
+	}
+
+	mIn = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		if item < mIn {
+			mIn = item
+			index = i
+		}
+	}
+
+	return mIn, index
 }
 
 // MinBy search the minimum value of a collection using the given comparison function.
 // If several values of the collection are equal to the smallest value, returns the first such value.
-func MinBy[T any](collection []T, comparison func(T, T) bool) T {
-	var min T
+// Returns zero value when the collection is empty.
+func MinBy[T any](collection []T, less func(a, b T) bool) T {
+	var mIn T
 
 	if len(collection) == 0 {
-		return min
+		return mIn
 	}
 
-	min = collection[0]
+	mIn = collection[0]
 
 	for i := 1; i < len(collection); i++ {
 		item := collection[i]
 
-		if comparison(item, min) {
-			min = item
+		if less(item, mIn) {
+			mIn = item
 		}
 	}
 
-	return min
+	return mIn
+}
+
+// MinByErr search the minimum value of a collection using the given comparison function.
+// If several values of the collection are equal to the smallest value, returns the first such value.
+// Returns zero value and nil error when the collection is empty.
+// If the comparison function returns an error, iteration stops and the error is returned.
+func MinByErr[T any](collection []T, less func(a, b T) (bool, error)) (T, error) {
+	var mIn T
+
+	if len(collection) == 0 {
+		return mIn, nil
+	}
+
+	mIn = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		isLess, err := less(item, mIn)
+		if err != nil {
+			var zero T
+			return zero, err
+		}
+		if isLess {
+			mIn = item
+		}
+	}
+
+	return mIn, nil
+}
+
+// MinIndexBy search the minimum value of a collection using the given comparison function and the index of the minimum value.
+// If several values of the collection are equal to the smallest value, returns the first such value.
+// Returns (zero value, -1) when the collection is empty.
+func MinIndexBy[T any](collection []T, less func(a, b T) bool) (T, int) {
+	var (
+		mIn   T
+		index int
+	)
+
+	if len(collection) == 0 {
+		return mIn, -1
+	}
+
+	mIn = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		if less(item, mIn) {
+			mIn = item
+			index = i
+		}
+	}
+
+	return mIn, index
+}
+
+// MinIndexByErr search the minimum value of a collection using the given comparison function and the index of the minimum value.
+// If several values of the collection are equal to the smallest value, returns the first such value.
+// Returns (zero value, -1) when the collection is empty.
+// Comparison function can return an error to stop iteration immediately.
+func MinIndexByErr[T any](collection []T, less func(a, b T) (bool, error)) (T, int, error) {
+	var (
+		mIn   T
+		index int
+	)
+
+	if len(collection) == 0 {
+		return mIn, -1, nil
+	}
+
+	mIn = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		isLess, err := less(item, mIn)
+		if err != nil {
+			var zero T
+			return zero, -1, err
+		}
+
+		if isLess {
+			mIn = item
+			index = i
+		}
+	}
+
+	return mIn, index, nil
+}
+
+// Earliest search the minimum time.Time of a collection.
+// Returns zero value when the collection is empty.
+func Earliest(times ...time.Time) time.Time {
+	var mIn time.Time
+
+	if len(times) == 0 {
+		return mIn
+	}
+
+	mIn = times[0]
+
+	for i := 1; i < len(times); i++ {
+		item := times[i]
+
+		if item.Before(mIn) {
+			mIn = item
+		}
+	}
+
+	return mIn
+}
+
+// EarliestBy search the minimum time.Time of a collection using the given iteratee function.
+// Returns zero value when the collection is empty.
+func EarliestBy[T any](collection []T, iteratee func(item T) time.Time) T {
+	var earliest T
+
+	if len(collection) == 0 {
+		return earliest
+	}
+
+	earliest = collection[0]
+	earliestTime := iteratee(collection[0])
+
+	for i := 1; i < len(collection); i++ {
+		itemTime := iteratee(collection[i])
+
+		if itemTime.Before(earliestTime) {
+			earliest = collection[i]
+			earliestTime = itemTime
+		}
+	}
+
+	return earliest
+}
+
+// EarliestByErr search the minimum time.Time of a collection using the given iteratee function.
+// Returns zero value and nil error when the collection is empty.
+// If the iteratee returns an error, iteration stops and the error is returned.
+func EarliestByErr[T any](collection []T, iteratee func(item T) (time.Time, error)) (T, error) {
+	var earliest T
+
+	if len(collection) == 0 {
+		return earliest, nil
+	}
+
+	earliestTime, err := iteratee(collection[0])
+	if err != nil {
+		return earliest, err
+	}
+	earliest = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		itemTime, err := iteratee(collection[i])
+		if err != nil {
+			return earliest, err
+		}
+
+		if itemTime.Before(earliestTime) {
+			earliest = collection[i]
+			earliestTime = itemTime
+		}
+	}
+
+	return earliest, nil
 }
 
 // Max searches the maximum value of a collection.
+// Returns zero value when the collection is empty.
+// Play: https://go.dev/play/p/r6e-Z8JozS8
 func Max[T constraints.Ordered](collection []T) T {
-	var max T
+	var mAx T
 
 	if len(collection) == 0 {
-		return max
+		return mAx
 	}
 
-	max = collection[0]
+	mAx = collection[0]
 
 	for i := 1; i < len(collection); i++ {
 		item := collection[i]
 
-		if item > max {
-			max = item
+		if item > mAx {
+			mAx = item
 		}
 	}
 
-	return max
+	return mAx
+}
+
+// MaxIndex searches the maximum value of a collection and the index of the maximum value.
+// Returns (zero value, -1) when the collection is empty.
+func MaxIndex[T constraints.Ordered](collection []T) (T, int) {
+	var (
+		mAx   T
+		index int
+	)
+
+	if len(collection) == 0 {
+		return mAx, -1
+	}
+
+	mAx = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		if item > mAx {
+			mAx = item
+			index = i
+		}
+	}
+
+	return mAx, index
 }
 
 // MaxBy search the maximum value of a collection using the given comparison function.
 // If several values of the collection are equal to the greatest value, returns the first such value.
-func MaxBy[T any](collection []T, comparison func(T, T) bool) T {
-	var max T
+// Returns zero value when the collection is empty.
+//
+// Note: the comparison function is inconsistent with most languages, since we use the opposite of the usual convention.
+// See https://github.com/samber/lo/issues/129
+//
+// Play: https://go.dev/play/p/JW1qu-ECwF7
+func MaxBy[T any](collection []T, greater func(a, b T) bool) T {
+	var mAx T
+
+	if len(collection) == 0 {
+		return mAx
+	}
+
+	mAx = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		if greater(item, mAx) {
+			mAx = item
+		}
+	}
+
+	return mAx
+}
+
+// MaxByErr search the maximum value of a collection using the given comparison function.
+// If several values of the collection are equal to the greatest value, returns the first such value.
+// Returns zero value and nil error when the collection is empty.
+// If the comparison function returns an error, iteration stops and the error is returned.
+//
+// Note: the comparison function is inconsistent with most languages, since we use the opposite of the usual convention.
+// See https://github.com/samber/lo/issues/129
+func MaxByErr[T any](collection []T, greater func(a, b T) (bool, error)) (T, error) {
+	var mAx T
+
+	if len(collection) == 0 {
+		return mAx, nil
+	}
+
+	mAx = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		isGreater, err := greater(item, mAx)
+		if err != nil {
+			return mAx, err
+		}
+		if isGreater {
+			mAx = item
+		}
+	}
+
+	return mAx, nil
+}
+
+// MaxIndexBy search the maximum value of a collection using the given comparison function and the index of the maximum value.
+// If several values of the collection are equal to the greatest value, returns the first such value.
+// Returns (zero value, -1) when the collection is empty.
+//
+// Note: the comparison function is inconsistent with most languages, since we use the opposite of the usual convention.
+// See https://github.com/samber/lo/issues/129
+//
+// Play: https://go.dev/play/p/uaUszc-c9QK
+func MaxIndexBy[T any](collection []T, greater func(a, b T) bool) (T, int) {
+	var (
+		mAx   T
+		index int
+	)
 
 	if len(collection) == 0 {
-		return max
+		return mAx, -1
 	}
 
-	max = collection[0]
+	mAx = collection[0]
 
 	for i := 1; i < len(collection); i++ {
 		item := collection[i]
 
-		if comparison(item, max) {
-			max = item
+		if greater(item, mAx) {
+			mAx = item
+			index = i
+		}
+	}
+
+	return mAx, index
+}
+
+// MaxIndexByErr search the maximum value of a collection using the given comparison function and the index of the maximum value.
+// If several values of the collection are equal to the greatest value, returns the first such value.
+// Returns (zero value, -1, nil) when the collection is empty.
+// If the comparison function returns an error, iteration stops and the error is returned.
+//
+// Note: the comparison function is inconsistent with most languages, since we use the opposite of the usual convention.
+// See https://github.com/samber/lo/issues/129
+func MaxIndexByErr[T any](collection []T, greater func(a, b T) (bool, error)) (T, int, error) {
+	var (
+		mAx   T
+		index int
+	)
+
+	if len(collection) == 0 {
+		return mAx, -1, nil
+	}
+
+	mAx = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		item := collection[i]
+
+		isGreater, err := greater(item, mAx)
+		if err != nil {
+			var zero T
+			return zero, -1, err
+		}
+		if isGreater {
+			mAx = item
+			index = i
+		}
+	}
+
+	return mAx, index, nil
+}
+
+// Latest search the maximum time.Time of a collection.
+// Returns zero value when the collection is empty.
+func Latest(times ...time.Time) time.Time {
+	var mAx time.Time
+
+	if len(times) == 0 {
+		return mAx
+	}
+
+	mAx = times[0]
+
+	for i := 1; i < len(times); i++ {
+		item := times[i]
+
+		if item.After(mAx) {
+			mAx = item
+		}
+	}
+
+	return mAx
+}
+
+// LatestBy search the maximum time.Time of a collection using the given iteratee function.
+// Returns zero value when the collection is empty.
+func LatestBy[T any](collection []T, iteratee func(item T) time.Time) T {
+	var latest T
+
+	if len(collection) == 0 {
+		return latest
+	}
+
+	latest = collection[0]
+	latestTime := iteratee(collection[0])
+
+	for i := 1; i < len(collection); i++ {
+		itemTime := iteratee(collection[i])
+
+		if itemTime.After(latestTime) {
+			latest = collection[i]
+			latestTime = itemTime
 		}
 	}
 
-	return max
+	return latest
+}
+
+// LatestByErr search the maximum time.Time of a collection using the given iteratee function.
+// Returns zero value and nil error when the collection is empty.
+// If the iteratee returns an error, iteration stops and the error is returned.
+func LatestByErr[T any](collection []T, iteratee func(item T) (time.Time, error)) (T, error) {
+	var latest T
+
+	if len(collection) == 0 {
+		return latest, nil
+	}
+
+	latestTime, err := iteratee(collection[0])
+	if err != nil {
+		return latest, err
+	}
+	latest = collection[0]
+
+	for i := 1; i < len(collection); i++ {
+		itemTime, err := iteratee(collection[i])
+		if err != nil {
+			return latest, err
+		}
+
+		if itemTime.After(latestTime) {
+			latest = collection[i]
+			latestTime = itemTime
+		}
+	}
+
+	return latest, nil
+}
+
+// First returns the first element of a collection and check for availability of the first element.
+// Play: https://go.dev/play/p/ul45Z0y2EFO
+func First[T any](collection []T) (T, bool) {
+	length := len(collection)
+
+	if length == 0 {
+		var t T
+		return t, false
+	}
+
+	return collection[0], true
+}
+
+// FirstOrEmpty returns the first element of a collection or zero value if empty.
+// Play: https://go.dev/play/p/ul45Z0y2EFO
+func FirstOrEmpty[T any](collection []T) T {
+	i, _ := First(collection)
+	return i
+}
+
+// FirstOr returns the first element of a collection or the fallback value if empty.
+// Play: https://go.dev/play/p/ul45Z0y2EFO
+func FirstOr[T any](collection []T, fallback T) T {
+	i, ok := First(collection)
+	if !ok {
+		return fallback
+	}
+
+	return i
 }
 
 // Last returns the last element of a collection or error if empty.
-func Last[T any](collection []T) (T, error) {
+// Play: https://go.dev/play/p/ul45Z0y2EFO
+func Last[T any](collection []T) (T, bool) {
 	length := len(collection)
 
 	if length == 0 {
 		var t T
-		return t, fmt.Errorf("last: cannot extract the last element of an empty slice")
+		return t, false
 	}
 
-	return collection[length-1], nil
+	return collection[length-1], true
+}
+
+// LastOrEmpty returns the last element of a collection or zero value if empty.
+// Play: https://go.dev/play/p/ul45Z0y2EFO
+func LastOrEmpty[T any](collection []T) T {
+	i, _ := Last(collection)
+	return i
+}
+
+// LastOr returns the last element of a collection or the fallback value if empty.
+// Play: https://go.dev/play/p/ul45Z0y2EFO
+func LastOr[T any](collection []T, fallback T) T {
+	i, ok := Last(collection)
+	if !ok {
+		return fallback
+	}
+
+	return i
 }
 
 // Nth returns the element at index `nth` of collection. If `nth` is negative, the nth element
 // from the end is returned. An error is returned when nth is out of slice bounds.
+// Play: https://go.dev/play/p/sHoh88KWt6B
 func Nth[T any, N constraints.Integer](collection []T, nth N) (T, error) {
+	value, ok := sliceNth(collection, nth)
+
+	return value, Validate(ok, "nth: %d out of slice bounds", nth)
+}
+
+func sliceNth[T any, N constraints.Integer](collection []T, nth N) (T, bool) {
 	n := int(nth)
 	l := len(collection)
 	if n >= l || -n > l {
-		var t T
-		return t, fmt.Errorf("nth: %d out of slice bounds", n)
+		return Empty[T](), false
 	}
 
 	if n >= 0 {
-		return collection[n], nil
+		return collection[n], true
 	}
-	return collection[l+n], nil
+	return collection[l+n], true
 }
 
+// NthOr returns the element at index `nth` of collection.
+// If `nth` is negative, it returns the nth element from the end.
+// If `nth` is out of slice bounds, it returns the fallback value instead of an error.
+// Play: https://go.dev/play/p/sHoh88KWt6B
+func NthOr[T any, N constraints.Integer](collection []T, nth N, fallback T) T {
+	value, ok := sliceNth(collection, nth)
+	if !ok {
+		return fallback
+	}
+	return value
+}
+
+// NthOrEmpty returns the element at index `nth` of collection.
+// If `nth` is negative, it returns the nth element from the end.
+// If `nth` is out of slice bounds, it returns the zero value (empty value) for that type.
+// Play: https://go.dev/play/p/sHoh88KWt6B
+func NthOrEmpty[T any, N constraints.Integer](collection []T, nth N) T {
+	value, _ := sliceNth(collection, nth)
+	return value
+}
+
+// randomIntGenerator is a function that should return a random integer in the range [0, n)
+// where n is the argument passed to the randomIntGenerator.
+type randomIntGenerator func(n int) int
+
 // Sample returns a random item from collection.
+// Play: https://go.dev/play/p/vCcSJbh5s6l
 func Sample[T any](collection []T) T {
+	return SampleBy(collection, xrand.IntN)
+}
+
+// SampleBy returns a random item from collection, using randomIntGenerator as the random index generator.
+// Play: https://go.dev/play/p/HDmKmMgq0XN
+func SampleBy[T any](collection []T, randomIntGenerator randomIntGenerator) T {
 	size := len(collection)
 	if size == 0 {
 		return Empty[T]()
 	}
-
-	return collection[rand.Intn(size)]
+	return collection[randomIntGenerator(size)]
 }
 
 // Samples returns N random unique items from collection.
-func Samples[T any](collection []T, count int) []T {
+// Play: https://go.dev/play/p/vCcSJbh5s6l
+func Samples[T any, Slice ~[]T](collection Slice, count int) Slice {
+	return SamplesBy(collection, count, xrand.IntN)
+}
+
+// SamplesBy returns N random unique items from collection, using randomIntGenerator as the random index generator.
+// Play: https://go.dev/play/p/HDmKmMgq0XN
+func SamplesBy[T any, Slice ~[]T](collection Slice, count int, randomIntGenerator randomIntGenerator) Slice {
+	if count <= 0 {
+		return Slice{}
+	}
+
 	size := len(collection)
 
-	cOpy := append([]T{}, collection...)
+	if size < count {
+		count = size
+	}
 
-	results := []T{}
+	indexes := Range(size)
+	results := make(Slice, count)
 
-	for i := 0; i < size && i < count; i++ {
-		copyLength := size - i
+	for i := range results {
+		n := len(indexes)
 
-		index := rand.Intn(size - i)
-		results = append(results, cOpy[index])
+		index := randomIntGenerator(n)
+		results[i] = collection[indexes[index]]
 
-		// Removes element.
+		// Removes index.
 		// It is faster to swap with last element and remove it.
-		cOpy[index] = cOpy[copyLength-1]
-		cOpy = cOpy[:copyLength-1]
+		indexes[index] = indexes[n-1]
+		indexes = indexes[:n-1]
 	}
 
 	return results
diff --git a/vendor/github.com/samber/lo/func.go b/vendor/github.com/samber/lo/func.go
index 90afc9ac262..c1e9c93bdf5 100644
--- a/vendor/github.com/samber/lo/func.go
+++ b/vendor/github.com/samber/lo/func.go
@@ -1,8 +1,47 @@
 package lo
 
 // Partial returns new function that, when called, has its first argument set to the provided value.
-func Partial[T1, T2, R any](f func(T1, T2) R, arg1 T1) func(T2) R {
+// Play: https://go.dev/play/p/Sy1gAQiQZ3v
+func Partial[T1, T2, R any](f func(a T1, b T2) R, arg1 T1) func(T2) R {
 	return func(t2 T2) R {
 		return f(arg1, t2)
 	}
 }
+
+// Partial1 returns new function that, when called, has its first argument set to the provided value.
+// Play: https://go.dev/play/p/D-ASTXCLBzw
+func Partial1[T1, T2, R any](f func(T1, T2) R, arg1 T1) func(T2) R {
+	return Partial(f, arg1)
+}
+
+// Partial2 returns new function that, when called, has its first argument set to the provided value.
+// Play: https://go.dev/play/p/-xiPjy4JChJ
+func Partial2[T1, T2, T3, R any](f func(T1, T2, T3) R, arg1 T1) func(T2, T3) R {
+	return func(t2 T2, t3 T3) R {
+		return f(arg1, t2, t3)
+	}
+}
+
+// Partial3 returns new function that, when called, has its first argument set to the provided value.
+// Play: https://go.dev/play/p/zWtSutpI26m
+func Partial3[T1, T2, T3, T4, R any](f func(T1, T2, T3, T4) R, arg1 T1) func(T2, T3, T4) R {
+	return func(t2 T2, t3 T3, t4 T4) R {
+		return f(arg1, t2, t3, t4)
+	}
+}
+
+// Partial4 returns new function that, when called, has its first argument set to the provided value.
+// Play: https://go.dev/play/p/kBrnnMTcJm0
+func Partial4[T1, T2, T3, T4, T5, R any](f func(T1, T2, T3, T4, T5) R, arg1 T1) func(T2, T3, T4, T5) R {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5) R {
+		return f(arg1, t2, t3, t4, t5)
+	}
+}
+
+// Partial5 returns new function that, when called, has its first argument set to the provided value.
+// Play: https://go.dev/play/p/7Is7K2y_VC3
+func Partial5[T1, T2, T3, T4, T5, T6, R any](f func(T1, T2, T3, T4, T5, T6) R, arg1 T1) func(T2, T3, T4, T5, T6) R {
+	return func(t2 T2, t3 T3, t4 T4, t5 T5, t6 T6) R {
+		return f(arg1, t2, t3, t4, t5, t6)
+	}
+}
diff --git a/vendor/github.com/samber/lo/internal/constraints/README.md b/vendor/github.com/samber/lo/internal/constraints/README.md
new file mode 100644
index 00000000000..27a3b1c49a9
--- /dev/null
+++ b/vendor/github.com/samber/lo/internal/constraints/README.md
@@ -0,0 +1,4 @@
+
+# Constraints
+
+This package is for Go 1.18 retrocompatiblity purpose.
diff --git a/vendor/github.com/samber/lo/internal/constraints/constraints.go b/vendor/github.com/samber/lo/internal/constraints/constraints.go
new file mode 100644
index 00000000000..3eb1cda55ff
--- /dev/null
+++ b/vendor/github.com/samber/lo/internal/constraints/constraints.go
@@ -0,0 +1,42 @@
+// Copyright 2021 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 constraints defines a set of useful constraints to be used
+// with type parameters.
+package constraints
+
+// Signed is a constraint that permits any signed integer type.
+// If future releases of Go add new predeclared signed integer types,
+// this constraint will be modified to include them.
+type Signed interface {
+	~int | ~int8 | ~int16 | ~int32 | ~int64
+}
+
+// Unsigned is a constraint that permits any unsigned integer type.
+// If future releases of Go add new predeclared unsigned integer types,
+// this constraint will be modified to include them.
+type Unsigned interface {
+	~uint | ~uint8 | ~uint16 | ~uint32 | ~uint64 | ~uintptr
+}
+
+// Integer is a constraint that permits any integer type.
+// If future releases of Go add new predeclared integer types,
+// this constraint will be modified to include them.
+type Integer interface {
+	Signed | Unsigned
+}
+
+// Float is a constraint that permits any floating-point type.
+// If future releases of Go add new predeclared floating-point types,
+// this constraint will be modified to include them.
+type Float interface {
+	~float32 | ~float64
+}
+
+// Complex is a constraint that permits any complex numeric type.
+// If future releases of Go add new predeclared complex numeric types,
+// this constraint will be modified to include them.
+type Complex interface {
+	~complex64 | ~complex128
+}
diff --git a/vendor/github.com/samber/lo/internal/constraints/ordered_go118.go b/vendor/github.com/samber/lo/internal/constraints/ordered_go118.go
new file mode 100644
index 00000000000..a124366fd39
--- /dev/null
+++ b/vendor/github.com/samber/lo/internal/constraints/ordered_go118.go
@@ -0,0 +1,11 @@
+//go:build !go1.21
+
+package constraints
+
+// Ordered is a constraint that permits any ordered type: any type
+// that supports the operators < <= >= >.
+// If future releases of Go add new ordered types,
+// this constraint will be modified to include them.
+type Ordered interface {
+	Integer | Float | ~string
+}
diff --git a/vendor/github.com/samber/lo/internal/constraints/ordered_go121.go b/vendor/github.com/samber/lo/internal/constraints/ordered_go121.go
new file mode 100644
index 00000000000..085a743641b
--- /dev/null
+++ b/vendor/github.com/samber/lo/internal/constraints/ordered_go121.go
@@ -0,0 +1,13 @@
+//go:build go1.21
+
+package constraints
+
+import (
+	"cmp"
+)
+
+// Ordered is a constraint that permits any ordered type: any type
+// that supports the operators < <= >= >.
+// If future releases of Go add new ordered types,
+// this constraint will be modified to include them.
+type Ordered = cmp.Ordered
diff --git a/vendor/github.com/samber/lo/internal/xrand/ordered_go118.go b/vendor/github.com/samber/lo/internal/xrand/ordered_go118.go
new file mode 100644
index 00000000000..410a5f34278
--- /dev/null
+++ b/vendor/github.com/samber/lo/internal/xrand/ordered_go118.go
@@ -0,0 +1,32 @@
+//go:build !go1.22
+
+package xrand
+
+import "math/rand"
+
+// Shuffle returns a slice of shuffled values. Uses the Fisher-Yates shuffle algorithm.
+func Shuffle(n int, swap func(i, j int)) {
+	rand.Shuffle(n, swap)
+}
+
+// IntN returns, as an int, a pseudo-random number in the half-open interval [0,n)
+// from the default Source.
+// It panics if n <= 0.
+func IntN(n int) int {
+	// bearer:disable go_gosec_crypto_weak_random
+	return rand.Intn(n)
+}
+
+// Int64 returns a non-negative pseudo-random 63-bit integer as an int64
+// from the default Source.
+func Int64() int64 {
+	// bearer:disable go_gosec_crypto_weak_random
+	n := rand.Int63()
+
+	// bearer:disable go_gosec_crypto_weak_random
+	if rand.Intn(2) == 0 {
+		return -n
+	}
+
+	return n
+}
diff --git a/vendor/github.com/samber/lo/internal/xrand/ordered_go122.go b/vendor/github.com/samber/lo/internal/xrand/ordered_go122.go
new file mode 100644
index 00000000000..6bca250e2c9
--- /dev/null
+++ b/vendor/github.com/samber/lo/internal/xrand/ordered_go122.go
@@ -0,0 +1,23 @@
+//go:build go1.22
+
+package xrand
+
+import "math/rand/v2"
+
+// Shuffle returns a slice of shuffled values. Uses the Fisher-Yates shuffle algorithm.
+func Shuffle(n int, swap func(i, j int)) {
+	rand.Shuffle(n, swap)
+}
+
+// IntN returns, as an int, a pseudo-random number in the half-open interval [0,n)
+// from the default Source.
+// It panics if n <= 0.
+func IntN(n int) int {
+	return rand.IntN(n)
+}
+
+// Int64 returns a non-negative pseudo-random 63-bit integer as an int64
+// from the default Source.
+func Int64() int64 {
+	return rand.Int64()
+}
diff --git a/vendor/github.com/samber/lo/internal/xtime/README.md b/vendor/github.com/samber/lo/internal/xtime/README.md
new file mode 100644
index 00000000000..73acd1e5fb2
--- /dev/null
+++ b/vendor/github.com/samber/lo/internal/xtime/README.md
@@ -0,0 +1,6 @@
+
+# xtime
+
+Lightweight mock for time package.
+
+A dedicated package such as [jonboulle/clockwork](https://github.com/jonboulle/clockwork/) would be better, but I would rather limit dependencies for this package. `clockwork` does not support Go 1.18 anymore.
diff --git a/vendor/github.com/samber/lo/internal/xtime/fake.go b/vendor/github.com/samber/lo/internal/xtime/fake.go
new file mode 100644
index 00000000000..380e238acbd
--- /dev/null
+++ b/vendor/github.com/samber/lo/internal/xtime/fake.go
@@ -0,0 +1,40 @@
+//nolint:revive
+package xtime
+
+import (
+	"time"
+)
+
+func NewFakeClock() *FakeClock {
+	return NewFakeClockAt(time.Now())
+}
+
+func NewFakeClockAt(t time.Time) *FakeClock {
+	return &FakeClock{
+		time: t,
+	}
+}
+
+type FakeClock struct {
+	_ noCopy
+
+	// Not protected by a mutex. If a warning is thrown in your tests,
+	// just disable parallel tests.
+	time time.Time
+}
+
+func (c *FakeClock) Now() time.Time {
+	return c.time
+}
+
+func (c *FakeClock) Since(t time.Time) time.Duration {
+	return c.time.Sub(t)
+}
+
+func (c *FakeClock) Until(t time.Time) time.Duration {
+	return t.Sub(c.time)
+}
+
+func (c *FakeClock) Sleep(d time.Duration) {
+	c.time = c.time.Add(d)
+}
diff --git a/vendor/github.com/samber/lo/internal/xtime/noCopy.go b/vendor/github.com/samber/lo/internal/xtime/noCopy.go
new file mode 100644
index 00000000000..9d425adf71b
--- /dev/null
+++ b/vendor/github.com/samber/lo/internal/xtime/noCopy.go
@@ -0,0 +1,14 @@
+package xtime
+
+// noCopy may be added to structs which must not be copied
+// after the first use.
+//
+// See https://golang.org/issues/8005#issuecomment-190753527
+// for details.
+//
+// Note that it must not be embedded, due to the Lock and Unlock methods.
+type noCopy struct{}
+
+// Lock is a no-op used by -copylocks checker from `go vet`.
+func (*noCopy) Lock()   {}
+func (*noCopy) Unlock() {}
diff --git a/vendor/github.com/samber/lo/internal/xtime/real.go b/vendor/github.com/samber/lo/internal/xtime/real.go
new file mode 100644
index 00000000000..df5a8dbde43
--- /dev/null
+++ b/vendor/github.com/samber/lo/internal/xtime/real.go
@@ -0,0 +1,30 @@
+//nolint:revive
+package xtime
+
+import (
+	"time"
+)
+
+func NewRealClock() *RealClock {
+	return &RealClock{}
+}
+
+type RealClock struct {
+	_ noCopy
+}
+
+func (c *RealClock) Now() time.Time {
+	return time.Now()
+}
+
+func (c *RealClock) Since(t time.Time) time.Duration {
+	return time.Since(t)
+}
+
+func (c *RealClock) Until(t time.Time) time.Duration {
+	return time.Until(t)
+}
+
+func (c *RealClock) Sleep(d time.Duration) {
+	time.Sleep(d)
+}
diff --git a/vendor/github.com/samber/lo/internal/xtime/time.go b/vendor/github.com/samber/lo/internal/xtime/time.go
new file mode 100644
index 00000000000..093a959ece7
--- /dev/null
+++ b/vendor/github.com/samber/lo/internal/xtime/time.go
@@ -0,0 +1,33 @@
+//nolint:revive
+package xtime
+
+import "time"
+
+var clock Clock = &RealClock{}
+
+func SetClock(c Clock) {
+	clock = c
+}
+
+func Now() time.Time {
+	return clock.Now()
+}
+
+func Since(t time.Time) time.Duration {
+	return clock.Since(t)
+}
+
+func Until(t time.Time) time.Duration {
+	return clock.Until(t)
+}
+
+func Sleep(d time.Duration) {
+	clock.Sleep(d)
+}
+
+type Clock interface {
+	Now() time.Time
+	Since(t time.Time) time.Duration
+	Until(t time.Time) time.Duration
+	Sleep(d time.Duration)
+}
diff --git a/vendor/github.com/samber/lo/intersect.go b/vendor/github.com/samber/lo/intersect.go
index 169cc2cf8b3..469cbbbf39c 100644
--- a/vendor/github.com/samber/lo/intersect.go
+++ b/vendor/github.com/samber/lo/intersect.go
@@ -1,9 +1,10 @@
 package lo
 
 // Contains returns true if an element is present in a collection.
+// Play: https://go.dev/play/p/W1EvyqY6t9j
 func Contains[T comparable](collection []T, element T) bool {
-	for _, item := range collection {
-		if item == element {
+	for i := range collection {
+		if collection[i] == element {
 			return true
 		}
 	}
@@ -12,9 +13,10 @@ func Contains[T comparable](collection []T, element T) bool {
 }
 
 // ContainsBy returns true if predicate function return true.
-func ContainsBy[T any](collection []T, predicate func(T) bool) bool {
-	for _, item := range collection {
-		if predicate(item) {
+// Play: https://go.dev/play/p/W1EvyqY6t9j
+func ContainsBy[T any](collection []T, predicate func(item T) bool) bool {
+	for i := range collection {
+		if predicate(collection[i]) {
 			return true
 		}
 	}
@@ -22,10 +24,17 @@ func ContainsBy[T any](collection []T, predicate func(T) bool) bool {
 	return false
 }
 
-// Every returns true if all elements of a subset are contained into a collection or if the subset is empty.
-func Every[T comparable](collection []T, subset []T) bool {
-	for _, elem := range subset {
-		if !Contains(collection, elem) {
+// Every returns true if all elements of a subset are contained in a collection or if the subset is empty.
+// Play: https://go.dev/play/p/W1EvyqY6t9j
+func Every[T comparable](collection, subset []T) bool {
+	if len(subset) == 0 {
+		return true
+	}
+
+	seen := Keyify(collection)
+
+	for _, item := range subset {
+		if _, ok := seen[item]; !ok {
 			return false
 		}
 	}
@@ -33,10 +42,11 @@ func Every[T comparable](collection []T, subset []T) bool {
 	return true
 }
 
-// EveryBy returns true if the predicate returns true for all of the elements in the collection or if the collection is empty.
-func EveryBy[V any](collection []V, predicate func(V) bool) bool {
-	for _, v := range collection {
-		if !predicate(v) {
+// EveryBy returns true if the predicate returns true for all elements in the collection or if the collection is empty.
+// Play: https://go.dev/play/p/dn1-vhHsq9x
+func EveryBy[T any](collection []T, predicate func(item T) bool) bool {
+	for i := range collection {
+		if !predicate(collection[i]) {
 			return false
 		}
 	}
@@ -44,11 +54,17 @@ func EveryBy[V any](collection []V, predicate func(V) bool) bool {
 	return true
 }
 
-// Some returns true if at least 1 element of a subset is contained into a collection.
+// Some returns true if at least 1 element of a subset is contained in a collection.
 // If the subset is empty Some returns false.
-func Some[T comparable](collection []T, subset []T) bool {
-	for _, elem := range subset {
-		if Contains(collection, elem) {
+// Play: https://go.dev/play/p/Lj4ceFkeT9V
+func Some[T comparable](collection, subset []T) bool {
+	if len(subset) == 0 {
+		return false
+	}
+
+	seen := Keyify(subset)
+	for i := range collection {
+		if _, ok := seen[collection[i]]; ok {
 			return true
 		}
 	}
@@ -58,9 +74,10 @@ func Some[T comparable](collection []T, subset []T) bool {
 
 // SomeBy returns true if the predicate returns true for any of the elements in the collection.
 // If the collection is empty SomeBy returns false.
-func SomeBy[V any](collection []V, predicate func(V) bool) bool {
-	for _, v := range collection {
-		if predicate(v) {
+// Play: https://go.dev/play/p/DXF-TORBudx
+func SomeBy[T any](collection []T, predicate func(item T) bool) bool {
+	for i := range collection {
+		if predicate(collection[i]) {
 			return true
 		}
 	}
@@ -68,10 +85,16 @@ func SomeBy[V any](collection []V, predicate func(V) bool) bool {
 	return false
 }
 
-// None returns true if no element of a subset are contained into a collection or if the subset is empty.
-func None[V comparable](collection []V, subset []V) bool {
-	for _, elem := range subset {
-		if Contains(collection, elem) {
+// None returns true if no element of a subset is contained in a collection or if the subset is empty.
+// Play: https://go.dev/play/p/fye7JsmxzPV
+func None[T comparable](collection, subset []T) bool {
+	if len(subset) == 0 {
+		return true
+	}
+
+	seen := Keyify(subset)
+	for i := range collection {
+		if _, ok := seen[collection[i]]; ok {
 			return false
 		}
 	}
@@ -80,9 +103,10 @@ func None[V comparable](collection []V, subset []V) bool {
 }
 
 // NoneBy returns true if the predicate returns true for none of the elements in the collection or if the collection is empty.
-func NoneBy[V any](collection []V, predicate func(V) bool) bool {
-	for _, v := range collection {
-		if predicate(v) {
+// Play: https://go.dev/play/p/O64WZ32H58S
+func NoneBy[T any](collection []T, predicate func(item T) bool) bool {
+	for i := range collection {
+		if predicate(collection[i]) {
 			return false
 		}
 	}
@@ -90,113 +114,250 @@ func NoneBy[V any](collection []V, predicate func(V) bool) bool {
 	return true
 }
 
-// Intersect returns the intersection between two collections.
-func Intersect[T comparable](list1 []T, list2 []T) []T {
-	result := []T{}
-	seen := map[T]struct{}{}
+// Intersect returns the intersection between collections.
+// Play: https://go.dev/play/p/uuElL9X9e58
+func Intersect[T comparable, Slice ~[]T](lists ...Slice) Slice {
+	if len(lists) == 0 {
+		return Slice{}
+	}
+
+	last := lists[len(lists)-1]
 
-	for _, elem := range list1 {
-		seen[elem] = struct{}{}
+	seen := make(map[T]bool, len(last))
+
+	for _, item := range last {
+		seen[item] = false
 	}
 
-	for _, elem := range list2 {
-		if _, ok := seen[elem]; ok {
-			result = append(result, elem)
+	for i := len(lists) - 2; i > 0 && len(seen) != 0; i-- {
+		for _, item := range lists[i] {
+			if _, ok := seen[item]; ok {
+				seen[item] = true
+			}
+		}
+
+		for k, v := range seen {
+			if v {
+				seen[k] = false
+			} else {
+				delete(seen, k)
+			}
+		}
+	}
+
+	result := make(Slice, 0, len(seen))
+
+	for _, item := range lists[0] {
+		if _, ok := seen[item]; ok {
+			result = append(result, item)
+			delete(seen, item)
 		}
 	}
 
 	return result
 }
 
-// Difference returns the difference between two collections.
-// The first value is the collection of element absent of list2.
-// The second value is the collection of element absent of list1.
-func Difference[T comparable](list1 []T, list2 []T) ([]T, []T) {
-	left := []T{}
-	right := []T{}
+// IntersectBy returns the intersection between two collections using a custom key selector function.
+func IntersectBy[T any, K comparable, Slice ~[]T](transform func(T) K, lists ...Slice) Slice {
+	if len(lists) == 0 {
+		return Slice{}
+	}
+
+	last := lists[len(lists)-1]
 
-	seenLeft := map[T]struct{}{}
-	seenRight := map[T]struct{}{}
+	seen := make(map[K]bool, len(last))
+
+	for _, item := range last {
+		k := transform(item)
+		seen[k] = false
+	}
+
+	for i := len(lists) - 2; i > 0 && len(seen) != 0; i-- {
+		for _, item := range lists[i] {
+			k := transform(item)
+			if _, ok := seen[k]; ok {
+				seen[k] = true
+			}
+		}
 
-	for _, elem := range list1 {
-		seenLeft[elem] = struct{}{}
+		for k, v := range seen {
+			if v {
+				seen[k] = false
+			} else {
+				delete(seen, k)
+			}
+		}
 	}
 
-	for _, elem := range list2 {
-		seenRight[elem] = struct{}{}
+	result := make(Slice, 0, len(seen))
+
+	for _, item := range lists[0] {
+		k := transform(item)
+		if _, ok := seen[k]; ok {
+			result = append(result, item)
+			delete(seen, k)
+		}
 	}
 
-	for _, elem := range list1 {
-		if _, ok := seenRight[elem]; !ok {
-			left = append(left, elem)
+	return result
+}
+
+// Difference returns the difference between two collections.
+// The first value is the collection of elements absent from list2.
+// The second value is the collection of elements absent from list1.
+// Play: https://go.dev/play/p/pKE-JgzqRpz
+func Difference[T comparable, Slice ~[]T](list1, list2 Slice) (Slice, Slice) {
+	left := Slice{}
+	right := Slice{}
+
+	seenLeft := Keyify(list1)
+	seenRight := Keyify(list2)
+
+	for i := range list1 {
+		if _, ok := seenRight[list1[i]]; !ok {
+			left = append(left, list1[i])
 		}
 	}
 
-	for _, elem := range list2 {
-		if _, ok := seenLeft[elem]; !ok {
-			right = append(right, elem)
+	for i := range list2 {
+		if _, ok := seenLeft[list2[i]]; !ok {
+			right = append(right, list2[i])
 		}
 	}
 
 	return left, right
 }
 
-// Union returns all distinct elements from both collections.
+// Union returns all distinct elements from given collections.
 // result returns will not change the order of elements relatively.
-func Union[T comparable](list1 []T, list2 []T) []T {
-	result := []T{}
+// Play: https://go.dev/play/p/DI9RVEB_qMK
+func Union[T comparable, Slice ~[]T](lists ...Slice) Slice {
+	var capLen int
 
-	seen := map[T]struct{}{}
-	hasAdd := map[T]struct{}{}
+	for _, list := range lists {
+		capLen += len(list)
+	}
 
-	for _, e := range list1 {
-		seen[e] = struct{}{}
+	result := make(Slice, 0, capLen)
+	seen := make(map[T]struct{}, capLen)
+
+	for i := range lists {
+		for j := range lists[i] {
+			if _, ok := seen[lists[i][j]]; !ok {
+				seen[lists[i][j]] = struct{}{}
+				result = append(result, lists[i][j])
+			}
+		}
 	}
 
-	for _, e := range list2 {
-		seen[e] = struct{}{}
+	return result
+}
+
+// Without returns a slice excluding all given values.
+// Play: https://go.dev/play/p/5j30Ux8TaD0
+func Without[T comparable, Slice ~[]T](collection Slice, exclude ...T) Slice {
+	excludeMap := Keyify(exclude)
+
+	result := make(Slice, 0, len(collection))
+	for i := range collection {
+		if _, ok := excludeMap[collection[i]]; !ok {
+			result = append(result, collection[i])
+		}
 	}
+	return result
+}
+
+// WithoutBy filters a slice by excluding elements whose extracted keys match any in the exclude list.
+// Returns a new slice containing only the elements whose keys are not in the exclude list.
+// Play: https://go.dev/play/p/VgWJOF01NbJ
+func WithoutBy[T any, K comparable, Slice ~[]T](collection Slice, iteratee func(item T) K, exclude ...K) Slice {
+	excludeMap := Keyify(exclude)
 
-	for _, e := range list1 {
-		if _, ok := seen[e]; ok {
-			result = append(result, e)
-			hasAdd[e] = struct{}{}
+	result := make(Slice, 0, len(collection))
+	for _, item := range collection {
+		if _, ok := excludeMap[iteratee(item)]; !ok {
+			result = append(result, item)
 		}
 	}
+	return result
+}
+
+// WithoutByErr filters a slice by excluding elements whose extracted keys match any in the exclude list.
+// It returns the first error returned by the iteratee.
+func WithoutByErr[T any, K comparable, Slice ~[]T](collection Slice, iteratee func(item T) (K, error), exclude ...K) (Slice, error) {
+	excludeMap := Keyify(exclude)
 
-	for _, e := range list2 {
-		if _, ok := hasAdd[e]; ok {
-			continue
+	result := make(Slice, 0, len(collection))
+	for _, item := range collection {
+		key, err := iteratee(item)
+		if err != nil {
+			return nil, err
 		}
-		if _, ok := seen[e]; ok {
-			result = append(result, e)
+		if _, ok := excludeMap[key]; !ok {
+			result = append(result, item)
 		}
 	}
+	return result, nil
+}
 
-	return result
+// WithoutEmpty returns a slice excluding zero values.
+//
+// Deprecated: Use lo.Compact instead.
+func WithoutEmpty[T comparable, Slice ~[]T](collection Slice) Slice {
+	return Compact(collection)
 }
 
-// Without returns slice excluding all given values.
-func Without[T comparable](collection []T, exclude ...T) []T {
-	result := make([]T, 0, len(collection))
-	for _, e := range collection {
-		if !Contains(exclude, e) {
-			result = append(result, e)
+// WithoutNth returns a slice excluding the nth value.
+// Play: https://go.dev/play/p/5g3F9R2H1xL
+func WithoutNth[T any, Slice ~[]T](collection Slice, nths ...int) Slice {
+	toRemove := Keyify(nths)
+
+	result := make(Slice, 0, len(collection))
+	for i := range collection {
+		if _, ok := toRemove[i]; !ok {
+			result = append(result, collection[i])
 		}
 	}
+
 	return result
 }
 
-// WithoutEmpty returns slice excluding empty values.
-func WithoutEmpty[T comparable](collection []T) []T {
-	var empty T
+// ElementsMatch returns true if lists contain the same set of elements (including empty set).
+// If there are duplicate elements, the number of occurrences in each list should match.
+// The order of elements is not checked.
+// Play: https://go.dev/play/p/XWSEM4Ic_t0
+func ElementsMatch[T comparable, Slice ~[]T](list1, list2 Slice) bool {
+	return ElementsMatchBy(list1, list2, func(item T) T { return item })
+}
+
+// ElementsMatchBy returns true if lists contain the same set of elements' keys (including empty set).
+// If there are duplicate keys, the number of occurrences in each list should match.
+// The order of elements is not checked.
+// Play: https://go.dev/play/p/XWSEM4Ic_t0
+func ElementsMatchBy[T any, K comparable](list1, list2 []T, iteratee func(item T) K) bool {
+	if len(list1) != len(list2) {
+		return false
+	}
+
+	if len(list1) == 0 {
+		return true
+	}
+
+	counters := make(map[K]int, len(list1))
+
+	for _, el := range list1 {
+		counters[iteratee(el)]++
+	}
+
+	for _, el := range list2 {
+		counters[iteratee(el)]--
+	}
 
-	result := make([]T, 0, len(collection))
-	for _, e := range collection {
-		if e != empty {
-			result = append(result, e)
+	for _, count := range counters {
+		if count != 0 {
+			return false
 		}
 	}
 
-	return result
+	return true
 }
diff --git a/vendor/github.com/samber/lo/map.go b/vendor/github.com/samber/lo/map.go
index 7915e37c3ea..e5c90e69b61 100644
--- a/vendor/github.com/samber/lo/map.go
+++ b/vendor/github.com/samber/lo/map.go
@@ -1,33 +1,109 @@
 package lo
 
-// Keys creates an array of the map keys.
+// Keys creates a slice of the map keys.
 // Play: https://go.dev/play/p/Uu11fHASqrU
-func Keys[K comparable, V any](in map[K]V) []K {
-	result := make([]K, 0, len(in))
+func Keys[K comparable, V any](in ...map[K]V) []K {
+	size := 0
+	for i := range in {
+		size += len(in[i])
+	}
+	result := make([]K, 0, size)
 
-	for k := range in {
-		result = append(result, k)
+	for i := range in {
+		for k := range in[i] {
+			result = append(result, k)
+		}
 	}
 
 	return result
 }
 
-// Values creates an array of the map values.
+// UniqKeys creates a slice of unique keys in the map.
+// Play: https://go.dev/play/p/TPKAb6ILdHk
+func UniqKeys[K comparable, V any](in ...map[K]V) []K {
+	size := 0
+	for i := range in {
+		size += len(in[i])
+	}
+
+	seen := make(map[K]struct{}, size)
+	result := make([]K, 0)
+
+	for i := range in {
+		for k := range in[i] {
+			if _, exists := seen[k]; exists {
+				continue
+			}
+			seen[k] = struct{}{}
+			result = append(result, k)
+		}
+	}
+
+	return result
+}
+
+// HasKey returns whether the given key exists.
+// Play: https://go.dev/play/p/aVwubIvECqS
+func HasKey[K comparable, V any](in map[K]V, key K) bool {
+	_, ok := in[key]
+	return ok
+}
+
+// Values creates a slice of the map values.
 // Play: https://go.dev/play/p/nnRTQkzQfF6
-func Values[K comparable, V any](in map[K]V) []V {
-	result := make([]V, 0, len(in))
+func Values[K comparable, V any](in ...map[K]V) []V {
+	size := 0
+	for i := range in {
+		size += len(in[i])
+	}
+	result := make([]V, 0, size)
 
-	for _, v := range in {
-		result = append(result, v)
+	for i := range in {
+		for _, v := range in[i] {
+			result = append(result, v)
+		}
 	}
 
 	return result
 }
 
+// UniqValues creates a slice of unique values in the map.
+// Play: https://go.dev/play/p/nf6bXMh7rM3
+func UniqValues[K, V comparable](in ...map[K]V) []V {
+	size := 0
+	for i := range in {
+		size += len(in[i])
+	}
+
+	seen := make(map[V]struct{}, size)
+	result := make([]V, 0)
+
+	for i := range in {
+		for _, v := range in[i] {
+			if _, exists := seen[v]; exists {
+				continue
+			}
+			seen[v] = struct{}{}
+			result = append(result, v)
+		}
+	}
+
+	return result
+}
+
+// ValueOr returns the value of the given key or the fallback value if the key is not present.
+// Play: https://go.dev/play/p/bAq9mHErB4V
+func ValueOr[K comparable, V any](in map[K]V, key K, fallback V) V {
+	if v, ok := in[key]; ok {
+		return v
+	}
+	return fallback
+}
+
 // PickBy returns same map type filtered by given predicate.
 // Play: https://go.dev/play/p/kdg8GR_QMmf
-func PickBy[K comparable, V any](in map[K]V, predicate func(K, V) bool) map[K]V {
-	r := map[K]V{}
+func PickBy[K comparable, V any, Map ~map[K]V](in Map, predicate func(key K, value V) bool) Map {
+	r := Map{}
 	for k, v := range in {
 		if predicate(k, v) {
 			r[k] = v
@@ -36,24 +112,42 @@ func PickBy[K comparable, V any](in map[K]V, predicate func(K, V) bool) map[K]V
 	return r
 }
 
-// PickByKeys returns same map type filtered by given keys.
-// Play: https://go.dev/play/p/R1imbuci9qU
-func PickByKeys[K comparable, V any](in map[K]V, keys []K) map[K]V {
-	r := map[K]V{}
+// PickByErr returns same map type filtered by given predicate.
+// It returns the first error returned by the predicate.
+func PickByErr[K comparable, V any, Map ~map[K]V](in Map, predicate func(key K, value V) (bool, error)) (Map, error) {
+	r := Map{}
 	for k, v := range in {
-		if Contains(keys, k) {
+		ok, err := predicate(k, v)
+		if err != nil {
+			return nil, err
+		}
+		if ok {
 			r[k] = v
 		}
 	}
+	return r, nil
+}
+
+// PickByKeys returns same map type filtered by given keys.
+// Play: https://go.dev/play/p/R1imbuci9qU
+func PickByKeys[K comparable, V any, Map ~map[K]V](in Map, keys []K) Map {
+	r := Map{}
+	for i := range keys {
+		if v, ok := in[keys[i]]; ok {
+			r[keys[i]] = v
+		}
+	}
 	return r
 }
 
 // PickByValues returns same map type filtered by given values.
 // Play: https://go.dev/play/p/1zdzSvbfsJc
-func PickByValues[K comparable, V comparable](in map[K]V, values []V) map[K]V {
-	r := map[K]V{}
+func PickByValues[K, V comparable, Map ~map[K]V](in Map, values []V) Map {
+	r := Map{}
+
+	seen := Keyify(values)
 	for k, v := range in {
-		if Contains(values, v) {
+		if _, ok := seen[v]; ok {
 			r[k] = v
 		}
 	}
@@ -62,8 +156,8 @@ func PickByValues[K comparable, V comparable](in map[K]V, values []V) map[K]V {
 
 // OmitBy returns same map type filtered by given predicate.
 // Play: https://go.dev/play/p/EtBsR43bdsd
-func OmitBy[K comparable, V any](in map[K]V, predicate func(K, V) bool) map[K]V {
-	r := map[K]V{}
+func OmitBy[K comparable, V any, Map ~map[K]V](in Map, predicate func(key K, value V) bool) Map {
+	r := Map{}
 	for k, v := range in {
 		if !predicate(k, v) {
 			r[k] = v
@@ -72,32 +166,52 @@ func OmitBy[K comparable, V any](in map[K]V, predicate func(K, V) bool) map[K]V
 	return r
 }
 
-// OmitByKeys returns same map type filtered by given keys.
-// Play: https://go.dev/play/p/t1QjCrs-ysk
-func OmitByKeys[K comparable, V any](in map[K]V, keys []K) map[K]V {
-	r := map[K]V{}
+// OmitByErr returns same map type filtered by given predicate.
+// It returns the first error returned by the predicate.
+func OmitByErr[K comparable, V any, Map ~map[K]V](in Map, predicate func(key K, value V) (bool, error)) (Map, error) {
+	r := Map{}
 	for k, v := range in {
-		if !Contains(keys, k) {
+		ok, err := predicate(k, v)
+		if err != nil {
+			return nil, err
+		}
+		if !ok {
 			r[k] = v
 		}
 	}
+	return r, nil
+}
+
+// OmitByKeys returns same map type filtered by given keys.
+// Play: https://go.dev/play/p/t1QjCrs-ysk
+func OmitByKeys[K comparable, V any, Map ~map[K]V](in Map, keys []K) Map {
+	r := Map{}
+	for k, v := range in {
+		r[k] = v
+	}
+	for i := range keys {
+		delete(r, keys[i])
+	}
 	return r
 }
 
 // OmitByValues returns same map type filtered by given values.
 // Play: https://go.dev/play/p/9UYZi-hrs8j
-func OmitByValues[K comparable, V comparable](in map[K]V, values []V) map[K]V {
-	r := map[K]V{}
+func OmitByValues[K, V comparable, Map ~map[K]V](in Map, values []V) Map {
+	r := Map{}
+
+	seen := Keyify(values)
 	for k, v := range in {
-		if !Contains(values, v) {
+		if _, ok := seen[v]; !ok {
 			r[k] = v
 		}
 	}
+
 	return r
 }
 
-// Entries transforms a map into array of key/value pairs.
-// Play:
+// Entries transforms a map into a slice of key/value pairs.
+// Play: https://go.dev/play/p/_t4Xe34-Nl5
 func Entries[K comparable, V any](in map[K]V) []Entry[K, V] {
 	entries := make([]Entry[K, V], 0, len(in))
 
@@ -111,26 +225,26 @@ func Entries[K comparable, V any](in map[K]V) []Entry[K, V] {
 	return entries
 }
 
-// ToPairs transforms a map into array of key/value pairs.
+// ToPairs transforms a map into a slice of key/value pairs.
 // Alias of Entries().
 // Play: https://go.dev/play/p/3Dhgx46gawJ
 func ToPairs[K comparable, V any](in map[K]V) []Entry[K, V] {
 	return Entries(in)
 }
 
-// FromEntries transforms an array of key/value pairs into a map.
+// FromEntries transforms a slice of key/value pairs into a map.
 // Play: https://go.dev/play/p/oIr5KHFGCEN
 func FromEntries[K comparable, V any](entries []Entry[K, V]) map[K]V {
-	out := map[K]V{}
+	out := make(map[K]V, len(entries))
 
-	for _, v := range entries {
-		out[v.Key] = v.Value
+	for i := range entries {
+		out[entries[i].Key] = entries[i].Value
 	}
 
 	return out
 }
 
-// FromPairs transforms an array of key/value pairs into a map.
+// FromPairs transforms a slice of key/value pairs into a map.
 // Alias of FromEntries().
 // Play: https://go.dev/play/p/oIr5KHFGCEN
 func FromPairs[K comparable, V any](entries []Entry[K, V]) map[K]V {
@@ -141,8 +255,8 @@ func FromPairs[K comparable, V any](entries []Entry[K, V]) map[K]V {
 // contains duplicate values, subsequent values overwrite property assignments
 // of previous values.
 // Play: https://go.dev/play/p/rFQ4rak6iA1
-func Invert[K comparable, V comparable](in map[K]V) map[V]K {
-	out := map[V]K{}
+func Invert[K, V comparable](in map[K]V) map[V]K {
+	out := make(map[V]K, len(in))
 
 	for k, v := range in {
 		out[v] = k
@@ -153,11 +267,15 @@ func Invert[K comparable, V comparable](in map[K]V) map[V]K {
 
 // Assign merges multiple maps from left to right.
 // Play: https://go.dev/play/p/VhwfJOyxf5o
-func Assign[K comparable, V any](maps ...map[K]V) map[K]V {
-	out := map[K]V{}
+func Assign[K comparable, V any, Map ~map[K]V](maps ...Map) Map {
+	count := 0
+	for i := range maps {
+		count += len(maps[i])
+	}
 
-	for _, m := range maps {
-		for k, v := range m {
+	out := make(Map, count)
+	for i := range maps {
+		for k, v := range maps[i] {
 			out[k] = v
 		}
 	}
@@ -165,10 +283,36 @@ func Assign[K comparable, V any](maps ...map[K]V) map[K]V {
 	return out
 }
 
-// MapKeys manipulates a map keys and transforms it to a map of another type.
+// ChunkEntries splits a map into a slice of elements in groups of length equal to its size. If the map cannot be split evenly,
+// the final chunk will contain the remaining elements.
+// Play: https://go.dev/play/p/X_YQL6mmoD-
+func ChunkEntries[K comparable, V any](m map[K]V, size int) []map[K]V {
+	if size <= 0 {
+		panic("lo.ChunkEntries: size must be greater than 0")
+	}
+
+	count := len(m)
+	if count == 0 {
+		return []map[K]V{}
+	}
+
+	result := make([]map[K]V, 0, ((count-1)/size)+1)
+
+	for k, v := range m {
+		if len(result) == 0 || len(result[len(result)-1]) == size {
+			result = append(result, make(map[K]V, size))
+		}
+
+		result[len(result)-1][k] = v
+	}
+
+	return result
+}
+
+// MapKeys manipulates map keys and transforms it to a map of another type.
 // Play: https://go.dev/play/p/9_4WPIqOetJ
-func MapKeys[K comparable, V any, R comparable](in map[K]V, iteratee func(V, K) R) map[R]V {
-	result := map[R]V{}
+func MapKeys[K comparable, V any, R comparable](in map[K]V, iteratee func(value V, key K) R) map[R]V {
+	result := make(map[R]V, len(in))
 
 	for k, v := range in {
 		result[iteratee(v, k)] = v
@@ -177,10 +321,26 @@ func MapKeys[K comparable, V any, R comparable](in map[K]V, iteratee func(V, K)
 	return result
 }
 
-// MapValues manipulates a map values and transforms it to a map of another type.
+// MapKeysErr manipulates map keys and transforms it to a map of another type.
+// It returns the first error returned by the iteratee.
+func MapKeysErr[K comparable, V any, R comparable](in map[K]V, iteratee func(value V, key K) (R, error)) (map[R]V, error) {
+	result := make(map[R]V, len(in))
+
+	for k, v := range in {
+		r, err := iteratee(v, k)
+		if err != nil {
+			return nil, err
+		}
+		result[r] = v
+	}
+
+	return result, nil
+}
+
+// MapValues manipulates map values and transforms it to a map of another type.
 // Play: https://go.dev/play/p/T_8xAfvcf0W
-func MapValues[K comparable, V any, R any](in map[K]V, iteratee func(V, K) R) map[K]R {
-	result := map[K]R{}
+func MapValues[K comparable, V, R any](in map[K]V, iteratee func(value V, key K) R) map[K]R {
+	result := make(map[K]R, len(in))
 
 	for k, v := range in {
 		result[k] = iteratee(v, k)
@@ -189,9 +349,54 @@ func MapValues[K comparable, V any, R any](in map[K]V, iteratee func(V, K) R) ma
 	return result
 }
 
-// MapToSlice transforms a map into a slice based on specific iteratee
+// MapValuesErr manipulates map values and transforms it to a map of another type.
+// It returns the first error returned by the iteratee.
+func MapValuesErr[K comparable, V, R any](in map[K]V, iteratee func(value V, key K) (R, error)) (map[K]R, error) {
+	result := make(map[K]R, len(in))
+
+	for k, v := range in {
+		r, err := iteratee(v, k)
+		if err != nil {
+			return nil, err
+		}
+		result[k] = r
+	}
+
+	return result, nil
+}
+
+// MapEntries manipulates map entries and transforms it to a map of another type.
+// Play: https://go.dev/play/p/VuvNQzxKimT
+func MapEntries[K1 comparable, V1 any, K2 comparable, V2 any](in map[K1]V1, iteratee func(key K1, value V1) (K2, V2)) map[K2]V2 {
+	result := make(map[K2]V2, len(in))
+
+	for k1 := range in {
+		k2, v2 := iteratee(k1, in[k1])
+		result[k2] = v2
+	}
+
+	return result
+}
+
+// MapEntriesErr manipulates map entries and transforms it to a map of another type.
+// It returns the first error returned by the iteratee.
+func MapEntriesErr[K1 comparable, V1 any, K2 comparable, V2 any](in map[K1]V1, iteratee func(key K1, value V1) (K2, V2, error)) (map[K2]V2, error) {
+	result := make(map[K2]V2, len(in))
+
+	for k1 := range in {
+		k2, v2, err := iteratee(k1, in[k1])
+		if err != nil {
+			return nil, err
+		}
+		result[k2] = v2
+	}
+
+	return result, nil
+}
+
+// MapToSlice transforms a map into a slice based on specified iteratee.
 // Play: https://go.dev/play/p/ZuiCZpDt6LD
-func MapToSlice[K comparable, V any, R any](in map[K]V, iteratee func(K, V) R) []R {
+func MapToSlice[K comparable, V, R any](in map[K]V, iteratee func(key K, value V) R) []R {
 	result := make([]R, 0, len(in))
 
 	for k, v := range in {
@@ -200,3 +405,129 @@ func MapToSlice[K comparable, V any, R any](in map[K]V, iteratee func(K, V) R) [
 
 	return result
 }
+
+// MapToSliceErr transforms a map into a slice based on specified iteratee.
+// It returns the first error returned by the iteratee.
+func MapToSliceErr[K comparable, V, R any](in map[K]V, iteratee func(key K, value V) (R, error)) ([]R, error) {
+	result := make([]R, 0, len(in))
+
+	for k, v := range in {
+		r, err := iteratee(k, v)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, r)
+	}
+
+	return result, nil
+}
+
+// FilterMapToSlice transforms a map into a slice based on specified iteratee.
+// The iteratee returns a value and a boolean. If the boolean is true, the value is added to the result slice.
+// If the boolean is false, the value is not added to the result slice.
+// The order of the keys in the input map is not specified and the order of the keys in the output slice is not guaranteed.
+// Play: https://go.dev/play/p/jgsD_Kil9pV
+func FilterMapToSlice[K comparable, V, R any](in map[K]V, iteratee func(key K, value V) (R, bool)) []R {
+	result := make([]R, 0, len(in))
+
+	for k, v := range in {
+		if v, ok := iteratee(k, v); ok {
+			result = append(result, v)
+		}
+	}
+
+	return result
+}
+
+// FilterMapToSliceErr transforms a map into a slice based on specified iteratee.
+// The iteratee returns a value, a boolean, and an error. If the boolean is true, the value is added to the result slice.
+// If the boolean is false, the value is not added to the result slice.
+// If an error is returned, iteration stops immediately and returns the error.
+// The order of the keys in the input map is not specified and the order of the keys in the output slice is not guaranteed.
+func FilterMapToSliceErr[K comparable, V, R any](in map[K]V, iteratee func(key K, value V) (R, bool, error)) ([]R, error) {
+	result := make([]R, 0, len(in))
+
+	for k, v := range in {
+		r, ok, err := iteratee(k, v)
+		if err != nil {
+			return nil, err
+		}
+		if ok {
+			result = append(result, r)
+		}
+	}
+
+	return result, nil
+}
+
+// FilterKeys transforms a map into a slice based on predicate returns true for specific elements.
+// It is a mix of lo.Filter() and lo.Keys().
+// Play: https://go.dev/play/p/OFlKXlPrBAe
+func FilterKeys[K comparable, V any](in map[K]V, predicate func(key K, value V) bool) []K {
+	result := make([]K, 0)
+
+	for k, v := range in {
+		if predicate(k, v) {
+			result = append(result, k)
+		}
+	}
+
+	return result
+}
+
+// FilterValues transforms a map into a slice based on predicate returns true for specific elements.
+// It is a mix of lo.Filter() and lo.Values().
+// Play: https://go.dev/play/p/YVD5r_h-LX-
+func FilterValues[K comparable, V any](in map[K]V, predicate func(key K, value V) bool) []V {
+	result := make([]V, 0)
+
+	for k, v := range in {
+		if predicate(k, v) {
+			result = append(result, v)
+		}
+	}
+
+	return result
+}
+
+// FilterKeysErr transforms a map into a slice of keys based on predicate that can return an error.
+// It is a mix of lo.Filter() and lo.Keys() with error handling.
+// If the predicate returns true, the key is added to the result slice.
+// If the predicate returns an error, iteration stops immediately and returns the error.
+// The order of the keys in the input map is not specified.
+func FilterKeysErr[K comparable, V any](in map[K]V, predicate func(key K, value V) (bool, error)) ([]K, error) {
+	result := make([]K, 0)
+
+	for k, v := range in {
+		ok, err := predicate(k, v)
+		if err != nil {
+			return nil, err
+		}
+		if ok {
+			result = append(result, k)
+		}
+	}
+
+	return result, nil
+}
+
+// FilterValuesErr transforms a map into a slice of values based on predicate that can return an error.
+// It is a mix of lo.Filter() and lo.Values() with error handling.
+// If the predicate returns true, the value is added to the result slice.
+// If the predicate returns an error, iteration stops immediately and returns the error.
+// The order of the keys in the input map is not specified.
+func FilterValuesErr[K comparable, V any](in map[K]V, predicate func(key K, value V) (bool, error)) ([]V, error) {
+	result := make([]V, 0)
+
+	for k, v := range in {
+		ok, err := predicate(k, v)
+		if err != nil {
+			return nil, err
+		}
+		if ok {
+			result = append(result, v)
+		}
+	}
+
+	return result, nil
+}
diff --git a/vendor/github.com/samber/lo/math.go b/vendor/github.com/samber/lo/math.go
index 30e7e9ef15f..f08f22789c3 100644
--- a/vendor/github.com/samber/lo/math.go
+++ b/vendor/github.com/samber/lo/math.go
@@ -1,51 +1,65 @@
 package lo
 
-import "golang.org/x/exp/constraints"
+import (
+	"math"
 
-// Range creates an array of numbers (positive and/or negative) with given length.
+	"github.com/samber/lo/internal/constraints"
+)
+
+// Range creates a slice of numbers (positive and/or negative) with given length.
 // Play: https://go.dev/play/p/0r6VimXAi9H
 func Range(elementNum int) []int {
-	length := If(elementNum < 0, -elementNum).Else(elementNum)
+	step := Ternary(elementNum < 0, -1, 1)
+	length := elementNum * step
 	result := make([]int, length)
-	step := If(elementNum < 0, -1).Else(1)
 	for i, j := 0, 0; i < length; i, j = i+1, j+step {
 		result[i] = j
 	}
 	return result
 }
 
-// RangeFrom creates an array of numbers from start with specified length.
+// RangeFrom creates a slice of numbers from start with specified length.
 // Play: https://go.dev/play/p/0r6VimXAi9H
 func RangeFrom[T constraints.Integer | constraints.Float](start T, elementNum int) []T {
-	length := If(elementNum < 0, -elementNum).Else(elementNum)
+	step := Ternary(elementNum < 0, -1, 1)
+	length := elementNum * step
 	result := make([]T, length)
-	step := If(elementNum < 0, -1).Else(1)
 	for i, j := 0, start; i < length; i, j = i+1, j+T(step) {
 		result[i] = j
 	}
 	return result
 }
 
-// RangeWithSteps creates an array of numbers (positive and/or negative) progressing from start up to, but not including end.
-// step set to zero will return empty array.
+// RangeWithSteps creates a slice of numbers (positive and/or negative) progressing from start up to, but not including end.
+// step set to zero will return an empty slice.
 // Play: https://go.dev/play/p/0r6VimXAi9H
 func RangeWithSteps[T constraints.Integer | constraints.Float](start, end, step T) []T {
-	result := []T{}
 	if start == end || step == 0 {
-		return result
+		return []T{}
+	}
+
+	capacity := func(count, delta T) int {
+		// Use math.Ceil instead of (count-1)/delta+1 because integer division
+		// fails for floats (e.g., 5.5/2.5=2.2 → ceil=3, not 2).
+		return int(math.Ceil(float64(count) / float64(delta)))
 	}
+
 	if start < end {
 		if step < 0 {
-			return result
+			return []T{}
 		}
+
+		result := make([]T, 0, capacity(end-start, step))
 		for i := start; i < end; i += step {
 			result = append(result, i)
 		}
 		return result
 	}
 	if step > 0 {
-		return result
+		return []T{}
 	}
+
+	result := make([]T, 0, capacity(start-end, -step))
 	for i := start; i > end; i += step {
 		result = append(result, i)
 	}
@@ -54,21 +68,146 @@ func RangeWithSteps[T constraints.Integer | constraints.Float](start, end, step
 
 // Clamp clamps number within the inclusive lower and upper bounds.
 // Play: https://go.dev/play/p/RU4lJNC2hlI
-func Clamp[T constraints.Ordered](value T, min T, max T) T {
-	if value < min {
-		return min
-	} else if value > max {
-		return max
+func Clamp[T constraints.Ordered](value, mIn, mAx T) T {
+	if value < mIn {
+		return mIn
+	} else if value > mAx {
+		return mAx
 	}
 	return value
 }
 
+// Sum sums the values in a collection. If collection is empty 0 is returned.
+// Play: https://go.dev/play/p/upfeJVqs4Bt
+func Sum[T constraints.Float | constraints.Integer | constraints.Complex](collection []T) T {
+	var sum T
+	for i := range collection {
+		sum += collection[i]
+	}
+	return sum
+}
+
 // SumBy summarizes the values in a collection using the given return value from the iteration function. If collection is empty 0 is returned.
 // Play: https://go.dev/play/p/Dz_a_7jN_ca
-func SumBy[T any, R constraints.Float | constraints.Integer](collection []T, iteratee func(T) R) R {
-	var sum R = 0
-	for _, item := range collection {
-		sum = sum + iteratee(item)
+func SumBy[T any, R constraints.Float | constraints.Integer | constraints.Complex](collection []T, iteratee func(item T) R) R {
+	var sum R
+	for i := range collection {
+		sum += iteratee(collection[i])
 	}
 	return sum
 }
+
+// SumByErr summarizes the values in a collection using the given return value from the iteration function.
+// If the iteratee returns an error, iteration stops and the error is returned.
+// If collection is empty 0 and nil error are returned.
+func SumByErr[T any, R constraints.Float | constraints.Integer | constraints.Complex](collection []T, iteratee func(item T) (R, error)) (R, error) {
+	var sum R
+	for i := range collection {
+		v, err := iteratee(collection[i])
+		if err != nil {
+			return sum, err
+		}
+		sum += v
+	}
+	return sum, nil
+}
+
+// Product gets the product of the values in a collection. If collection is empty 1 is returned.
+// Play: https://go.dev/play/p/2_kjM_smtAH
+func Product[T constraints.Float | constraints.Integer | constraints.Complex](collection []T) T {
+	var product T = 1
+	for i := range collection {
+		product *= collection[i]
+	}
+	return product
+}
+
+// ProductBy summarizes the values in a collection using the given return value from the iteration function. If collection is empty 1 is returned.
+// Play: https://go.dev/play/p/wadzrWr9Aer
+func ProductBy[T any, R constraints.Float | constraints.Integer | constraints.Complex](collection []T, iteratee func(item T) R) R {
+	var product R = 1
+	for i := range collection {
+		product *= iteratee(collection[i])
+	}
+	return product
+}
+
+// ProductByErr summarizes the values in a collection using the given return value from the iteration function.
+// If the iteratee returns an error, iteration stops and the error is returned.
+// If collection is empty 1 and nil error are returned.
+func ProductByErr[T any, R constraints.Float | constraints.Integer | constraints.Complex](collection []T, iteratee func(item T) (R, error)) (R, error) {
+	var product R = 1
+	for i := range collection {
+		v, err := iteratee(collection[i])
+		if err != nil {
+			return product, err
+		}
+		product *= v
+	}
+	return product, nil
+}
+
+// Mean calculates the mean of a collection of numbers.
+// Play: https://go.dev/play/p/tPURSuteUsP
+func Mean[T constraints.Float | constraints.Integer](collection []T) T {
+	length := T(len(collection))
+	if length == 0 {
+		return 0
+	}
+	sum := Sum(collection)
+	return sum / length
+}
+
+// MeanBy calculates the mean of a collection of numbers using the given return value from the iteration function.
+// Play: https://go.dev/play/p/j7TsVwBOZ7P
+func MeanBy[T any, R constraints.Float | constraints.Integer](collection []T, iteratee func(item T) R) R {
+	length := R(len(collection))
+	if length == 0 {
+		return 0
+	}
+	sum := SumBy(collection, iteratee)
+	return sum / length
+}
+
+// MeanByErr calculates the mean of a collection of numbers using the given return value from the iteration function.
+// If the iteratee returns an error, iteration stops and the error is returned.
+// If collection is empty 0 and nil error are returned.
+func MeanByErr[T any, R constraints.Float | constraints.Integer](collection []T, iteratee func(item T) (R, error)) (R, error) {
+	length := R(len(collection))
+	if length == 0 {
+		return 0, nil
+	}
+	sum, err := SumByErr(collection, iteratee)
+	if err != nil {
+		return 0, err
+	}
+	return sum / length, nil
+}
+
+// Mode returns the mode (most frequent value) of a collection.
+// If multiple values have the same highest frequency, then multiple values are returned.
+// If the collection is empty, then the zero value of T is returned.
+func Mode[T constraints.Integer | constraints.Float](collection []T) []T {
+	length := T(len(collection))
+	if length == 0 {
+		return []T{}
+	}
+
+	mode := make([]T, 0)
+	maxFreq := 0
+	frequency := make(map[T]int)
+
+	for _, item := range collection {
+		frequency[item]++
+		count := frequency[item]
+
+		if count > maxFreq {
+			maxFreq = count
+			mode = []T{item}
+		} else if count == maxFreq {
+			mode = append(mode, item)
+		}
+	}
+
+	return mode
+}
diff --git a/vendor/github.com/samber/lo/mutable/slice.go b/vendor/github.com/samber/lo/mutable/slice.go
new file mode 100644
index 00000000000..4b8e916c497
--- /dev/null
+++ b/vendor/github.com/samber/lo/mutable/slice.go
@@ -0,0 +1,73 @@
+package mutable
+
+import "github.com/samber/lo/internal/xrand"
+
+// Filter is a generic function that modifies the input slice in-place to contain only the elements
+// that satisfy the provided predicate function. The predicate function takes an element of the slice and its index,
+// and should return true for elements that should be kept and false for elements that should be removed.
+// The function returns the modified slice, which may be shorter than the original if some elements were removed.
+// Note that the order of elements in the original slice is preserved in the output.
+// Play: https://go.dev/play/p/0jY3Z0B7O_5
+func Filter[T any, Slice ~[]T](collection Slice, predicate func(item T) bool) Slice {
+	j := 0
+	for i := range collection {
+		if predicate(collection[i]) {
+			collection[j] = collection[i]
+			j++
+		}
+	}
+	return collection[:j]
+}
+
+// FilterI is a generic function that modifies the input slice in-place to contain only the elements
+// that satisfy the provided predicate function. The predicate function takes an element of the slice and its index,
+// and should return true for elements that should be kept and false for elements that should be removed.
+// The function returns the modified slice, which may be shorter than the original if some elements were removed.
+// Note that the order of elements in the original slice is preserved in the output.
+func FilterI[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) bool) Slice {
+	j := 0
+	for i := range collection {
+		if predicate(collection[i], i) {
+			collection[j] = collection[i]
+			j++
+		}
+	}
+	return collection[:j]
+}
+
+// Map is a generic function that modifies the input slice in-place to contain the result of applying the provided
+// function to each element of the slice. The function returns the modified slice, which has the same length as the original.
+// Play: https://go.dev/play/p/0jY3Z0B7O_5
+func Map[T any, Slice ~[]T](collection Slice, transform func(item T) T) {
+	for i := range collection {
+		collection[i] = transform(collection[i])
+	}
+}
+
+// MapI is a generic function that modifies the input slice in-place to contain the result of applying the provided
+// function to each element of the slice. The function returns the modified slice, which has the same length as the original.
+func MapI[T any, Slice ~[]T](collection Slice, transform func(item T, index int) T) {
+	for i := range collection {
+		collection[i] = transform(collection[i], i)
+	}
+}
+
+// Shuffle returns a slice of shuffled values. Uses the Fisher-Yates shuffle algorithm.
+// Play: https://go.dev/play/p/2xb3WdLjeSJ
+func Shuffle[T any, Slice ~[]T](collection Slice) {
+	xrand.Shuffle(len(collection), func(i, j int) {
+		collection[i], collection[j] = collection[j], collection[i]
+	})
+}
+
+// Reverse reverses a slice so that the first element becomes the last, the second element becomes the second to last, and so on.
+// Play: https://go.dev/play/p/O-M5pmCRgzV
+func Reverse[T any, Slice ~[]T](collection Slice) {
+	length := len(collection)
+	half := length / 2
+
+	for i := 0; i < half; i++ {
+		j := length - 1 - i
+		collection[i], collection[j] = collection[j], collection[i]
+	}
+}
diff --git a/vendor/github.com/samber/lo/retry.go b/vendor/github.com/samber/lo/retry.go
index b4a61efba04..a4779f60f37 100644
--- a/vendor/github.com/samber/lo/retry.go
+++ b/vendor/github.com/samber/lo/retry.go
@@ -3,6 +3,8 @@ package lo
 import (
 	"sync"
 	"time"
+
+	"github.com/samber/lo/internal/xtime"
 )
 
 type debounce struct {
@@ -13,12 +15,12 @@ type debounce struct {
 	callbacks []func()
 }
 
-func (d *debounce) reset() *debounce {
+func (d *debounce) reset() {
 	d.mu.Lock()
 	defer d.mu.Unlock()
 
 	if d.done {
-		return d
+		return
 	}
 
 	if d.timer != nil {
@@ -26,11 +28,15 @@ func (d *debounce) reset() *debounce {
 	}
 
 	d.timer = time.AfterFunc(d.after, func() {
-		for _, f := range d.callbacks {
-			f()
+		// We need to lock the mutex here to avoid race conditions with 2 concurrent calls to reset()
+		d.mu.Lock()
+		callbacks := append([]func(){}, d.callbacks...)
+		d.mu.Unlock()
+
+		for i := range callbacks {
+			callbacks[i]()
 		}
 	})
-	return d
 }
 
 func (d *debounce) cancel() {
@@ -61,9 +67,92 @@ func NewDebounce(duration time.Duration, f ...func()) (func(), func()) {
 	}, d.cancel
 }
 
-// Attempt invokes a function N times until it returns valid output. Returning either the caught error or nil. When first argument is less than `1`, the function runs until a successful response is returned.
+type debounceByItem struct {
+	mu    *sync.Mutex
+	timer *time.Timer
+	count int
+}
+
+type debounceBy[T comparable] struct {
+	after     time.Duration
+	mu        *sync.Mutex
+	items     map[T]*debounceByItem
+	callbacks []func(key T, count int)
+}
+
+func (d *debounceBy[T]) reset(key T) {
+	d.mu.Lock()
+	if _, ok := d.items[key]; !ok {
+		d.items[key] = &debounceByItem{
+			mu:    new(sync.Mutex),
+			timer: nil,
+		}
+	}
+
+	item := d.items[key]
+
+	d.mu.Unlock()
+
+	item.mu.Lock()
+	defer item.mu.Unlock()
+
+	item.count++
+
+	if item.timer != nil {
+		item.timer.Stop()
+	}
+
+	item.timer = time.AfterFunc(d.after, func() {
+		// We need to lock the mutex here to avoid race conditions with 2 concurrent calls to reset()
+		item.mu.Lock()
+		count := item.count
+		item.count = 0
+		callbacks := append([]func(key T, count int){}, d.callbacks...)
+		item.mu.Unlock()
+
+		for i := range callbacks {
+			callbacks[i](key, count)
+		}
+	})
+}
+
+func (d *debounceBy[T]) cancel(key T) {
+	d.mu.Lock()
+	defer d.mu.Unlock()
+
+	if item, ok := d.items[key]; ok {
+		item.mu.Lock()
+
+		if item.timer != nil {
+			item.timer.Stop()
+			item.timer = nil
+		}
+
+		item.mu.Unlock()
+
+		delete(d.items, key)
+	}
+}
+
+// NewDebounceBy creates a debounced instance for each distinct key, that delays invoking functions given until after wait milliseconds have elapsed.
+// Play: https://go.dev/play/p/d3Vpt6pxhY8
+func NewDebounceBy[T comparable](duration time.Duration, f ...func(key T, count int)) (func(key T), func(key T)) {
+	d := &debounceBy[T]{
+		after:     duration,
+		mu:        new(sync.Mutex),
+		items:     map[T]*debounceByItem{},
+		callbacks: f,
+	}
+
+	return func(key T) {
+		d.reset(key)
+	}, d.cancel
+}
+
+// Attempt invokes a function N times until it returns valid output. Returns either the caught error or nil.
+// When the first argument is less than `1`, the function runs until a successful response is returned.
 // Play: https://go.dev/play/p/3ggJZ2ZKcMj
-func Attempt(maxIteration int, f func(int) error) (int, error) {
+func Attempt(maxIteration int, f func(index int) error) (int, error) {
 	var err error
 
 	for i := 0; maxIteration <= 0 || i < maxIteration; i++ {
@@ -78,27 +167,222 @@ func Attempt(maxIteration int, f func(int) error) (int, error) {
 }
 
 // AttemptWithDelay invokes a function N times until it returns valid output,
-// with a pause between each call. Returning either the caught error or nil.
-// When first argument is less than `1`, the function runs until a successful
+// with a pause between each call. Returns either the caught error or nil.
+// When the first argument is less than `1`, the function runs until a successful
 // response is returned.
 // Play: https://go.dev/play/p/tVs6CygC7m1
-func AttemptWithDelay(maxIteration int, delay time.Duration, f func(int, time.Duration) error) (int, time.Duration, error) {
+func AttemptWithDelay(maxIteration int, delay time.Duration, f func(index int, duration time.Duration) error) (int, time.Duration, error) {
+	var err error
+
+	start := xtime.Now()
+
+	for i := 0; maxIteration <= 0 || i < maxIteration; i++ {
+		err = f(i, xtime.Since(start))
+		if err == nil {
+			return i + 1, xtime.Since(start), nil
+		}
+
+		if maxIteration <= 0 || i+1 < maxIteration {
+			xtime.Sleep(delay)
+		}
+	}
+
+	return maxIteration, xtime.Since(start), err
+}
+
+// AttemptWhile invokes a function N times until it returns valid output.
+// Returns either the caught error or nil, along with a bool value to determine
+// whether the function should be invoked again. It will terminate the invoke
+// immediately if the second return value is false. When the first
+// argument is less than `1`, the function runs until a successful response is
+// returned.
+// Play: https://go.dev/play/p/1VS7HxlYMOG
+func AttemptWhile(maxIteration int, f func(int) (error, bool)) (int, error) {
+	var err error
+	var shouldContinueInvoke bool
+
+	for i := 0; maxIteration <= 0 || i < maxIteration; i++ {
+		// for retries >= 0 {
+		err, shouldContinueInvoke = f(i)
+		if !shouldContinueInvoke { // if shouldContinueInvoke is false, then return immediately
+			return i + 1, err
+		}
+		if err == nil {
+			return i + 1, nil
+		}
+	}
+
+	return maxIteration, err
+}
+
+// AttemptWhileWithDelay invokes a function N times until it returns valid output,
+// with a pause between each call. Returns either the caught error or nil, along
+// with a bool value to determine whether the function should be invoked again.
+// It will terminate the invoke immediately if the second return value is false.
+// When the first argument is less than `1`, the function runs until a successful
+// response is returned.
+// Play: https://go.dev/play/p/mhufUjJfLEF
+func AttemptWhileWithDelay(maxIteration int, delay time.Duration, f func(int, time.Duration) (error, bool)) (int, time.Duration, error) {
 	var err error
+	var shouldContinueInvoke bool
 
-	start := time.Now()
+	start := xtime.Now()
 
 	for i := 0; maxIteration <= 0 || i < maxIteration; i++ {
-		err = f(i, time.Since(start))
+		err, shouldContinueInvoke = f(i, xtime.Since(start))
+		if !shouldContinueInvoke { // if shouldContinueInvoke is false, then return immediately
+			return i + 1, xtime.Since(start), err
+		}
 		if err == nil {
-			return i + 1, time.Since(start), nil
+			return i + 1, xtime.Since(start), nil
 		}
 
 		if maxIteration <= 0 || i+1 < maxIteration {
-			time.Sleep(delay)
+			xtime.Sleep(delay)
+		}
+	}
+
+	return maxIteration, xtime.Since(start), err
+}
+
+type transactionStep[T any] struct {
+	exec       func(T) (T, error)
+	onRollback func(T) T
+}
+
+// NewTransaction instantiate a new transaction.
+// Play: https://go.dev/play/p/Qxrd7MGQGh1
+func NewTransaction[T any]() *Transaction[T] {
+	return &Transaction[T]{
+		steps: []transactionStep[T]{},
+	}
+}
+
+// Transaction implements a Saga pattern.
+type Transaction[T any] struct {
+	steps []transactionStep[T]
+}
+
+// Then adds a step to the chain of callbacks. Returns the same Transaction.
+// Play: https://go.dev/play/p/Qxrd7MGQGh1 https://go.dev/play/p/xrHb2_kMvTY
+func (t *Transaction[T]) Then(exec func(T) (T, error), onRollback func(T) T) *Transaction[T] {
+	t.steps = append(t.steps, transactionStep[T]{
+		exec:       exec,
+		onRollback: onRollback,
+	})
+
+	return t
+}
+
+// Process runs the Transaction steps and rollbacks in case of errors.
+// Play: https://go.dev/play/p/Qxrd7MGQGh1 https://go.dev/play/p/xrHb2_kMvTY
+func (t *Transaction[T]) Process(state T) (T, error) {
+	var i int
+	var err error
+
+	for i < len(t.steps) {
+		state, err = t.steps[i].exec(state)
+		if err != nil {
+			break
+		}
+
+		i++
+	}
+
+	if err == nil {
+		return state, nil
+	}
+
+	for i > 0 {
+		i--
+		state = t.steps[i].onRollback(state)
+	}
+
+	return state, err
+}
+
+// @TODO: single mutex per key?
+type throttleBy[T comparable] struct {
+	mu         *sync.Mutex
+	timer      *time.Timer
+	interval   time.Duration
+	callbacks  []func(key T)
+	countLimit int
+	count      map[T]int
+}
+
+func (th *throttleBy[T]) throttledFunc(key T) {
+	th.mu.Lock()
+	defer th.mu.Unlock()
+
+	if th.count[key] < th.countLimit {
+		th.count[key]++
+
+		for _, f := range th.callbacks {
+			f(key)
 		}
 	}
+	if th.timer == nil {
+		th.timer = time.AfterFunc(th.interval, func() {
+			th.reset()
+		})
+	}
+}
+
+func (th *throttleBy[T]) reset() {
+	th.mu.Lock()
+	defer th.mu.Unlock()
+
+	if th.timer != nil {
+		th.timer.Stop()
+	}
+
+	th.count = map[T]int{}
+	th.timer = nil
+}
 
-	return maxIteration, time.Since(start), err
+// NewThrottle creates a throttled instance that invokes given functions only once in every interval.
+// This returns 2 functions, First one is throttled function and Second one is a function to reset interval.
+// Play: https://go.dev/play/p/qQn3fm8Z7jS
+func NewThrottle(interval time.Duration, f ...func()) (throttle, reset func()) {
+	return NewThrottleWithCount(interval, 1, f...)
 }
 
-// throttle ?
+// NewThrottleWithCount is NewThrottle with count limit, throttled function will be invoked count times in every interval.
+// Play: https://go.dev/play/p/w5nc0MgWtjC
+func NewThrottleWithCount(interval time.Duration, count int, f ...func()) (throttle, reset func()) {
+	callbacks := Map(f, func(item func(), _ int) func(struct{}) {
+		return func(struct{}) {
+			item()
+		}
+	})
+
+	throttleFn, reset := NewThrottleByWithCount(interval, count, callbacks...)
+	return func() {
+		throttleFn(struct{}{})
+	}, reset
+}
+
+// NewThrottleBy creates a throttled instance that invokes given functions only once in every interval.
+// This returns 2 functions, First one is throttled function and Second one is a function to reset interval.
+// Play: https://go.dev/play/p/0Wv6oX7dHdC
+func NewThrottleBy[T comparable](interval time.Duration, f ...func(key T)) (throttle func(key T), reset func()) {
+	return NewThrottleByWithCount(interval, 1, f...)
+}
+
+// NewThrottleByWithCount is NewThrottleBy with count limit, throttled function will be invoked count times in every interval.
+// Play: https://go.dev/play/p/vQk3ECH7_EW
+func NewThrottleByWithCount[T comparable](interval time.Duration, count int, f ...func(key T)) (throttle func(key T), reset func()) {
+	if count <= 0 {
+		count = 1
+	}
+
+	th := &throttleBy[T]{
+		mu:         new(sync.Mutex),
+		interval:   interval,
+		callbacks:  f,
+		countLimit: count,
+		count:      map[T]int{},
+	}
+	return th.throttledFunc, th.reset
+}
diff --git a/vendor/github.com/samber/lo/slice.go b/vendor/github.com/samber/lo/slice.go
index 516fc8b1771..a53da54f84e 100644
--- a/vendor/github.com/samber/lo/slice.go
+++ b/vendor/github.com/samber/lo/slice.go
@@ -1,48 +1,99 @@
 package lo
 
 import (
-	"math/rand"
+	"sort"
 
-	"golang.org/x/exp/constraints"
+	"github.com/samber/lo/internal/constraints"
+	"github.com/samber/lo/mutable"
 )
 
-// Filter iterates over elements of collection, returning an array of all elements predicate returns truthy for.
+// Filter iterates over elements of collection, returning a slice of all elements predicate returns true for.
 // Play: https://go.dev/play/p/Apjg3WeSi7K
-func Filter[V any](collection []V, predicate func(V, int) bool) []V {
-	result := []V{}
+func Filter[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) bool) Slice {
+	result := make(Slice, 0, len(collection))
 
-	for i, item := range collection {
-		if predicate(item, i) {
-			result = append(result, item)
+	for i := range collection {
+		if predicate(collection[i], i) {
+			result = append(result, collection[i])
 		}
 	}
 
 	return result
 }
 
+// FilterErr iterates over elements of collection, returning a slice of all elements predicate returns true for.
+// If the predicate returns an error, iteration stops immediately and returns the error.
+// Play: https://go.dev/play/p/Apjg3WeSi7K
+func FilterErr[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) (bool, error)) (Slice, error) {
+	result := make(Slice, 0, len(collection))
+
+	for i := range collection {
+		ok, err := predicate(collection[i], i)
+		if err != nil {
+			return nil, err
+		}
+		if ok {
+			result = append(result, collection[i])
+		}
+	}
+
+	return result, nil
+}
+
 // Map manipulates a slice and transforms it to a slice of another type.
 // Play: https://go.dev/play/p/OkPcYAhBo0D
-func Map[T any, R any](collection []T, iteratee func(T, int) R) []R {
+func Map[T, R any](collection []T, transform func(item T, index int) R) []R {
 	result := make([]R, len(collection))
 
-	for i, item := range collection {
-		result[i] = iteratee(item, i)
+	for i := range collection {
+		result[i] = transform(collection[i], i)
 	}
 
 	return result
 }
 
-// FilterMap returns a slice which obtained after both filtering and mapping using the given callback function.
+// MapErr manipulates a slice and transforms it to a slice of another type.
+// It returns the first error returned by the transform function.
+func MapErr[T, R any](collection []T, transform func(item T, index int) (R, error)) ([]R, error) {
+	result := make([]R, len(collection))
+
+	for i := range collection {
+		r, err := transform(collection[i], i)
+		if err != nil {
+			return nil, err
+		}
+		result[i] = r
+	}
+
+	return result, nil
+}
+
+// UniqMap manipulates a slice and transforms it to a slice of another type with unique values.
+// Play: https://go.dev/play/p/fygzLBhvUdB
+func UniqMap[T any, R comparable](collection []T, transform func(item T, index int) R) []R {
+	seen := make(map[R]struct{}, len(collection))
+
+	for i := range collection {
+		r := transform(collection[i], i)
+		if _, ok := seen[r]; !ok {
+			seen[r] = struct{}{}
+		}
+	}
+
+	return Keys(seen)
+}
+
+// FilterMap returns a slice obtained after both filtering and mapping using the given callback function.
 // The callback function should return two values:
 //   - the result of the mapping operation and
 //   - whether the result element should be included or not.
 //
-// Play: https://go.dev/play/p/-AuYXfy7opz
-func FilterMap[T any, R any](collection []T, callback func(T, int) (R, bool)) []R {
-	result := []R{}
+// Play: https://go.dev/play/p/CgHYNUpOd1I
+func FilterMap[T, R any](collection []T, callback func(item T, index int) (R, bool)) []R {
+	result := make([]R, 0, len(collection))
 
-	for i, item := range collection {
-		if r, ok := callback(item, i); ok {
+	for i := range collection {
+		if r, ok := callback(collection[i], i); ok {
 			result = append(result, r)
 		}
 	}
@@ -51,31 +102,67 @@ func FilterMap[T any, R any](collection []T, callback func(T, int) (R, bool)) []
 }
 
 // FlatMap manipulates a slice and transforms and flattens it to a slice of another type.
-// Play: https://go.dev/play/p/YSoYmQTA8-U
-func FlatMap[T any, R any](collection []T, iteratee func(T, int) []R) []R {
-	result := []R{}
+// The transform function can either return a slice or a `nil`, and in the `nil` case
+// no value is added to the final slice.
+// Play: https://go.dev/play/p/pFCF5WVB225
+func FlatMap[T, R any](collection []T, transform func(item T, index int) []R) []R {
+	result := make([]R, 0, len(collection))
 
-	for i, item := range collection {
-		result = append(result, iteratee(item, i)...)
+	for i := range collection {
+		result = append(result, transform(collection[i], i)...)
 	}
 
 	return result
 }
 
+// FlatMapErr manipulates a slice and transforms and flattens it to a slice of another type.
+// The transform function can either return a slice or a `nil`, and in the `nil` case
+// no value is added to the final slice.
+// It returns the first error returned by the transform function.
+func FlatMapErr[T, R any](collection []T, transform func(item T, index int) ([]R, error)) ([]R, error) {
+	result := make([]R, 0, len(collection))
+
+	for i := range collection {
+		r, err := transform(collection[i], i)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, r...)
+	}
+
+	return result, nil
+}
+
 // Reduce reduces collection to a value which is the accumulated result of running each element in collection
 // through accumulator, where each successive invocation is supplied the return value of the previous.
-// Play: https://go.dev/play/p/R4UHXZNaaUG
-func Reduce[T any, R any](collection []T, accumulator func(R, T, int) R, initial R) R {
-	for i, item := range collection {
-		initial = accumulator(initial, item, i)
+// Play: https://go.dev/play/p/CgHYNUpOd1I
+func Reduce[T, R any](collection []T, accumulator func(agg R, item T, index int) R, initial R) R {
+	for i := range collection {
+		initial = accumulator(initial, collection[i], i)
 	}
 
 	return initial
 }
 
-// ReduceRight helper is like Reduce except that it iterates over elements of collection from right to left.
+// ReduceErr reduces collection to a value which is the accumulated result of running each element in collection
+// through accumulator, where each successive invocation is supplied the return value of the previous.
+// It returns the first error returned by the accumulator function.
+func ReduceErr[T, R any](collection []T, accumulator func(agg R, item T, index int) (R, error), initial R) (R, error) {
+	for i := range collection {
+		result, err := accumulator(initial, collection[i], i)
+		if err != nil {
+			var zero R
+			return zero, err
+		}
+		initial = result
+	}
+
+	return initial, nil
+}
+
+// ReduceRight is like Reduce except that it iterates over elements of collection from right to left.
 // Play: https://go.dev/play/p/Fq3W70l7wXF
-func ReduceRight[T any, R any](collection []T, accumulator func(R, T, int) R, initial R) R {
+func ReduceRight[T, R any](collection []T, accumulator func(agg R, item T, index int) R, initial R) R {
 	for i := len(collection) - 1; i >= 0; i-- {
 		initial = accumulator(initial, collection[i], i)
 	}
@@ -83,18 +170,44 @@ func ReduceRight[T any, R any](collection []T, accumulator func(R, T, int) R, in
 	return initial
 }
 
-// ForEach iterates over elements of collection and invokes iteratee for each element.
+// ReduceRightErr is like ReduceRight except that the accumulator function can return an error.
+// It returns the first error returned by the accumulator function.
+func ReduceRightErr[T, R any](collection []T, accumulator func(agg R, item T, index int) (R, error), initial R) (R, error) {
+	for i := len(collection) - 1; i >= 0; i-- {
+		result, err := accumulator(initial, collection[i], i)
+		if err != nil {
+			var zero R
+			return zero, err
+		}
+		initial = result
+	}
+
+	return initial, nil
+}
+
+// ForEach iterates over elements of collection and invokes callback for each element.
 // Play: https://go.dev/play/p/oofyiUPRf8t
-func ForEach[T any](collection []T, iteratee func(T, int)) {
-	for i, item := range collection {
-		iteratee(item, i)
+func ForEach[T any](collection []T, callback func(item T, index int)) {
+	for i := range collection {
+		callback(collection[i], i)
+	}
+}
+
+// ForEachWhile iterates over elements of collection and invokes predicate for each element
+// collection return value decide to continue or break, like do while().
+// Play: https://go.dev/play/p/QnLGt35tnow
+func ForEachWhile[T any](collection []T, predicate func(item T, index int) bool) {
+	for i := range collection {
+		if !predicate(collection[i], i) {
+			break
+		}
 	}
 }
 
-// Times invokes the iteratee n times, returning an array of the results of each invocation.
+// Times invokes the iteratee n times, returning a slice of the results of each invocation.
 // The iteratee is invoked with index as argument.
 // Play: https://go.dev/play/p/vgQj3Glr6lT
-func Times[T any](count int, iteratee func(int) T) []T {
+func Times[T any](count int, iteratee func(index int) T) []T {
 	result := make([]T, count)
 
 	for i := 0; i < count; i++ {
@@ -104,106 +217,182 @@ func Times[T any](count int, iteratee func(int) T) []T {
 	return result
 }
 
-// Uniq returns a duplicate-free version of an array, in which only the first occurrence of each element is kept.
-// The order of result values is determined by the order they occur in the array.
+// Uniq returns a duplicate-free version of a slice, in which only the first occurrence of each element is kept.
+// The order of result values is determined by the order they occur in the slice.
 // Play: https://go.dev/play/p/DTzbeXZ6iEN
-func Uniq[T comparable](collection []T) []T {
-	result := make([]T, 0, len(collection))
+func Uniq[T comparable, Slice ~[]T](collection Slice) Slice {
+	result := make(Slice, 0, len(collection))
 	seen := make(map[T]struct{}, len(collection))
 
-	for _, item := range collection {
-		if _, ok := seen[item]; ok {
+	for i := range collection {
+		if _, ok := seen[collection[i]]; ok {
 			continue
 		}
 
-		seen[item] = struct{}{}
-		result = append(result, item)
+		seen[collection[i]] = struct{}{}
+		result = append(result, collection[i])
 	}
 
 	return result
 }
 
-// UniqBy returns a duplicate-free version of an array, in which only the first occurrence of each element is kept.
-// The order of result values is determined by the order they occur in the array. It accepts `iteratee` which is
-// invoked for each element in array to generate the criterion by which uniqueness is computed.
+// UniqBy returns a duplicate-free version of a slice, in which only the first occurrence of each element is kept.
+// The order of result values is determined by the order they occur in the slice. It accepts `iteratee` which is
+// invoked for each element in the slice to generate the criterion by which uniqueness is computed.
 // Play: https://go.dev/play/p/g42Z3QSb53u
-func UniqBy[T any, U comparable](collection []T, iteratee func(T) U) []T {
-	result := make([]T, 0, len(collection))
+func UniqBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) Slice {
+	result := make(Slice, 0, len(collection))
 	seen := make(map[U]struct{}, len(collection))
 
-	for _, item := range collection {
-		key := iteratee(item)
+	for i := range collection {
+		key := iteratee(collection[i])
 
 		if _, ok := seen[key]; ok {
 			continue
 		}
 
 		seen[key] = struct{}{}
-		result = append(result, item)
+		result = append(result, collection[i])
 	}
 
 	return result
 }
 
+// UniqByErr returns a duplicate-free version of a slice, in which only the first occurrence of each element is kept.
+// The order of result values is determined by the order they occur in the slice. It accepts `iteratee` which is
+// invoked for each element in the slice to generate the criterion by which uniqueness is computed.
+// It returns the first error returned by the iteratee function.
+func UniqByErr[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) (U, error)) (Slice, error) {
+	result := make(Slice, 0, len(collection))
+	seen := make(map[U]struct{}, len(collection))
+
+	for i := range collection {
+		key, err := iteratee(collection[i])
+		if err != nil {
+			return nil, err
+		}
+
+		if _, ok := seen[key]; ok {
+			continue
+		}
+
+		seen[key] = struct{}{}
+		result = append(result, collection[i])
+	}
+
+	return result, nil
+}
+
 // GroupBy returns an object composed of keys generated from the results of running each element of collection through iteratee.
 // Play: https://go.dev/play/p/XnQBd_v6brd
-func GroupBy[T any, U comparable](collection []T, iteratee func(T) U) map[U][]T {
-	result := map[U][]T{}
+func GroupBy[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) U) map[U]Slice {
+	result := map[U]Slice{}
 
-	for _, item := range collection {
-		key := iteratee(item)
+	for i := range collection {
+		key := iteratee(collection[i])
 
-		result[key] = append(result[key], item)
+		result[key] = append(result[key], collection[i])
 	}
 
 	return result
 }
 
-// Chunk returns an array of elements split into groups the length of size. If array can't be split evenly,
+// GroupByErr returns an object composed of keys generated from the results of running each element of collection through iteratee.
+// It returns the first error returned by the iteratee function.
+func GroupByErr[T any, U comparable, Slice ~[]T](collection Slice, iteratee func(item T) (U, error)) (map[U]Slice, error) {
+	result := map[U]Slice{}
+
+	for i := range collection {
+		key, err := iteratee(collection[i])
+		if err != nil {
+			return nil, err
+		}
+
+		result[key] = append(result[key], collection[i])
+	}
+
+	return result, nil
+}
+
+// GroupByMap returns an object composed of keys generated from the results of running each element of collection through transform.
+// Play: https://go.dev/play/p/iMeruQ3_W80
+func GroupByMap[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K][]V {
+	result := map[K][]V{}
+
+	for i := range collection {
+		k, v := transform(collection[i])
+
+		result[k] = append(result[k], v)
+	}
+
+	return result
+}
+
+// GroupByMapErr returns an object composed of keys generated from the results of running each element of collection through transform.
+// It returns the first error returned by the transform function.
+func GroupByMapErr[T any, K comparable, V any](collection []T, transform func(item T) (K, V, error)) (map[K][]V, error) {
+	result := map[K][]V{}
+
+	for i := range collection {
+		k, v, err := transform(collection[i])
+		if err != nil {
+			return nil, err
+		}
+
+		result[k] = append(result[k], v)
+	}
+
+	return result, nil
+}
+
+// Chunk returns a slice of elements split into groups of length size. If the slice can't be split evenly,
 // the final chunk will be the remaining elements.
-// Play: https://go.dev/play/p/EeKl0AuTehH
-func Chunk[T any](collection []T, size int) [][]T {
+// Play: https://go.dev/play/p/kEMkFbdu85g
+func Chunk[T any, Slice ~[]T](collection Slice, size int) []Slice {
 	if size <= 0 {
-		panic("Second parameter must be greater than 0")
+		panic("lo.Chunk: size must be greater than 0")
 	}
 
 	chunksNum := len(collection) / size
 	if len(collection)%size != 0 {
-		chunksNum += 1
+		chunksNum++
 	}
 
-	result := make([][]T, 0, chunksNum)
+	result := make([]Slice, 0, chunksNum)
 
 	for i := 0; i < chunksNum; i++ {
 		last := (i + 1) * size
 		if last > len(collection) {
 			last = len(collection)
 		}
-		result = append(result, collection[i*size:last])
+
+		// Copy chunk in a new slice, to prevent memory leak and free memory from initial collection.
+		newSlice := make(Slice, last-i*size)
+		copy(newSlice, collection[i*size:last])
+		result = append(result, newSlice)
 	}
 
 	return result
 }
 
-// PartitionBy returns an array of elements split into groups. The order of grouped values is
+// PartitionBy returns a slice of elements split into groups. The order of grouped values is
 // determined by the order they occur in collection. The grouping is generated from the results
 // of running each element of collection through iteratee.
 // Play: https://go.dev/play/p/NfQ_nGjkgXW
-func PartitionBy[T any, K comparable](collection []T, iteratee func(x T) K) [][]T {
-	result := [][]T{}
+func PartitionBy[T any, K comparable, Slice ~[]T](collection Slice, iteratee func(item T) K) []Slice {
+	result := []Slice{}
 	seen := map[K]int{}
 
-	for _, item := range collection {
-		key := iteratee(item)
+	for i := range collection {
+		key := iteratee(collection[i])
 
 		resultIndex, ok := seen[key]
-		if !ok {
-			resultIndex = len(result)
-			seen[key] = resultIndex
-			result = append(result, []T{})
+		if ok {
+			result[resultIndex] = append(result[resultIndex], collection[i])
+		} else {
+			seen[key] = len(result)
+			result = append(result, Slice{collection[i]})
 		}
-
-		result[resultIndex] = append(result[resultIndex], item)
 	}
 
 	return result
@@ -213,15 +402,42 @@ func PartitionBy[T any, K comparable](collection []T, iteratee func(x T) K) [][]
 	// return Values[K, []T](groups)
 }
 
-// Flatten returns an array a single level deep.
+// PartitionByErr partitions a slice into groups determined by a key computed from each element.
+// The order of the partitions is determined by the order they occur in collection. The grouping
+// is generated from the results of running each element of collection through iteratee.
+// It returns the first error returned by the iteratee function.
+func PartitionByErr[T any, K comparable, Slice ~[]T](collection Slice, iteratee func(item T) (K, error)) ([]Slice, error) {
+	result := []Slice{}
+	seen := map[K]int{}
+
+	for i := range collection {
+		key, err := iteratee(collection[i])
+		if err != nil {
+			return nil, err
+		}
+
+		resultIndex, ok := seen[key]
+		if ok {
+			result[resultIndex] = append(result[resultIndex], collection[i])
+		} else {
+			seen[key] = len(result)
+			result = append(result, Slice{collection[i]})
+		}
+	}
+
+	return result, nil
+}
+
+// Flatten returns a slice a single level deep.
+// See also: Concat
 // Play: https://go.dev/play/p/rbp9ORaMpjw
-func Flatten[T any](collection [][]T) []T {
+func Flatten[T any, Slice ~[]T](collection []Slice) Slice {
 	totalLen := 0
 	for i := range collection {
 		totalLen += len(collection[i])
 	}
 
-	result := make([]T, 0, totalLen)
+	result := make(Slice, 0, totalLen)
 	for i := range collection {
 		result = append(result, collection[i]...)
 	}
@@ -229,34 +445,110 @@ func Flatten[T any](collection [][]T) []T {
 	return result
 }
 
-// Shuffle returns an array of shuffled values. Uses the Fisher-Yates shuffle algorithm.
-// Play: https://go.dev/play/p/Qp73bnTDnc7
-func Shuffle[T any](collection []T) []T {
-	rand.Shuffle(len(collection), func(i, j int) {
-		collection[i], collection[j] = collection[j], collection[i]
-	})
+// Concat returns a new slice containing all the elements in collections. Concat conserves the order of the elements.
+// See also: Flatten, Union.
+func Concat[T any, Slice ~[]T](collections ...Slice) Slice {
+	return Flatten(collections)
+}
 
-	return collection
+// Window creates a slice of sliding windows of a given size.
+// Each window overlaps with the previous one by size-1 elements.
+// This is equivalent to Sliding(collection, size, 1).
+func Window[T any, Slice ~[]T](collection Slice, size int) []Slice {
+	if size <= 0 {
+		panic("lo.Window: size must be greater than 0")
+	}
+	return Sliding(collection, size, 1)
 }
 
-// Reverse reverses array so that the first element becomes the last, the second element becomes the second to last, and so on.
-// Play: https://go.dev/play/p/fhUMLvZ7vS6
-func Reverse[T any](collection []T) []T {
-	length := len(collection)
-	half := length / 2
+// Sliding creates a slice of sliding windows of a given size with a given step.
+// If step is equal to size, windows don't overlap (similar to Chunk).
+// If step is less than size, windows overlap.
+func Sliding[T any, Slice ~[]T](collection Slice, size, step int) []Slice {
+	if size <= 0 {
+		panic("lo.Sliding: size must be greater than 0")
+	}
+
+	if step <= 0 {
+		panic("lo.Sliding: step must be greater than 0")
+	}
+
+	n := len(collection) - size
+	if n < 0 {
+		return []Slice{}
+	}
+
+	result := make([]Slice, 0, n/step+1)
+
+	for i := 0; i <= n; i += step {
+		window := make(Slice, size)
+		copy(window, collection[i:i+size])
+		result = append(result, window)
+	}
 
-	for i := 0; i < half; i = i + 1 {
-		j := length - 1 - i
-		collection[i], collection[j] = collection[j], collection[i]
+	return result
+}
+
+// Interleave round-robin alternating input slices and sequentially appending value at index into result.
+// Play: https://go.dev/play/p/-RJkTLQEDVt
+func Interleave[T any, Slice ~[]T](collections ...Slice) Slice {
+	if len(collections) == 0 {
+		return Slice{}
+	}
+
+	maxSize := 0
+	totalSize := 0
+	for i := range collections {
+		size := len(collections[i])
+		totalSize += size
+		if size > maxSize {
+			maxSize = size
+		}
+	}
+
+	if maxSize == 0 {
+		return Slice{}
+	}
+
+	result := make(Slice, totalSize)
+
+	resultIdx := 0
+	for i := 0; i < maxSize; i++ {
+		for j := range collections {
+			if len(collections[j])-1 < i {
+				continue
+			}
+
+			result[resultIdx] = collections[j][i]
+			resultIdx++
+		}
 	}
 
+	return result
+}
+
+// Shuffle returns a slice of shuffled values. Uses the Fisher-Yates shuffle algorithm.
+// Play: https://go.dev/play/p/ZTGG7OUCdnp
+//
+// Deprecated: use mutable.Shuffle() instead.
+func Shuffle[T any, Slice ~[]T](collection Slice) Slice {
+	mutable.Shuffle(collection)
+	return collection
+}
+
+// Reverse reverses a slice so that the first element becomes the last, the second element becomes the second to last, and so on.
+// Play: https://go.dev/play/p/iv2e9jslfBM
+//
+// Deprecated: use mutable.Reverse() instead.
+func Reverse[T any, Slice ~[]T](collection Slice) Slice {
+	mutable.Reverse(collection)
 	return collection
 }
 
-// Fill fills elements of array with `initial` value.
+// Fill fills elements of a slice with `initial` value.
 // Play: https://go.dev/play/p/VwR34GzqEub
-func Fill[T Clonable[T]](collection []T, initial T) []T {
-	result := make([]T, 0, len(collection))
+func Fill[T Clonable[T], Slice ~[]T](collection Slice, initial T) Slice {
+	result := make(Slice, 0, len(collection))
 
 	for range collection {
 		result = append(result, initial.Clone())
@@ -279,38 +571,81 @@ func Repeat[T Clonable[T]](count int, initial T) []T {
 
 // RepeatBy builds a slice with values returned by N calls of callback.
 // Play: https://go.dev/play/p/ozZLCtX_hNU
-func RepeatBy[T any](count int, predicate func(int) T) []T {
+func RepeatBy[T any](count int, callback func(index int) T) []T {
 	result := make([]T, 0, count)
 
 	for i := 0; i < count; i++ {
-		result = append(result, predicate(i))
+		result = append(result, callback(i))
 	}
 
 	return result
 }
 
-// KeyBy transforms a slice or an array of structs to a map based on a pivot callback.
-// Play: https://go.dev/play/p/mdaClUAT-zZ
-func KeyBy[K comparable, V any](collection []V, iteratee func(V) K) map[K]V {
+// RepeatByErr builds a slice with values returned by N calls of callback.
+// It returns the first error returned by the callback function.
+func RepeatByErr[T any](count int, callback func(index int) (T, error)) ([]T, error) {
+	result := make([]T, 0, count)
+
+	for i := 0; i < count; i++ {
+		r, err := callback(i)
+		if err != nil {
+			return nil, err
+		}
+		result = append(result, r)
+	}
+
+	return result, nil
+}
+
+// KeyBy transforms a slice or a slice of structs to a map based on a pivot callback.
+// Play: https://go.dev/play/p/ccUiUL_Lnel
+func KeyBy[K comparable, V any](collection []V, iteratee func(item V) K) map[K]V {
 	result := make(map[K]V, len(collection))
 
-	for _, v := range collection {
-		k := iteratee(v)
-		result[k] = v
+	for i := range collection {
+		k := iteratee(collection[i])
+		result[k] = collection[i]
 	}
 
 	return result
 }
 
+// KeyByErr transforms a slice or a slice of structs to a map based on a pivot callback to compute keys.
+// Iteratee can return an error to stop iteration immediately.
+// Play: https://go.dev/play/p/ccUiUL_Lnel
+func KeyByErr[K comparable, V any](collection []V, iteratee func(item V) (K, error)) (map[K]V, error) {
+	result := make(map[K]V, len(collection))
+
+	for i := range collection {
+		k, err := iteratee(collection[i])
+		if err != nil {
+			return nil, err
+		}
+		result[k] = collection[i]
+	}
+
+	return result, nil
+}
+
 // Associate returns a map containing key-value pairs provided by transform function applied to elements of the given slice.
-// If any of two pairs would have the same key the last one gets added to the map.
-// The order of keys in returned map is not specified and is not guaranteed to be the same from the original array.
+// If any of two pairs have the same key the last one gets added to the map.
+// The order of keys in returned map is not specified and is not guaranteed to be the same from the original slice.
 // Play: https://go.dev/play/p/WHa2CfMO3Lr
-func Associate[T any, K comparable, V any](collection []T, transform func(T) (K, V)) map[K]V {
-	result := make(map[K]V)
+func Associate[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K]V {
+	return AssociateI(collection, func(item T, _ int) (K, V) {
+		return transform(item)
+	})
+}
+
+// AssociateI returns a map containing key-value pairs provided by transform function applied to elements of the given slice.
+// If any of two pairs have the same key the last one gets added to the map.
+// The order of keys in returned map is not specified and is not guaranteed to be the same from the original slice.
+// Play: https://go.dev/play/p/Ugmz6S22rRO
+func AssociateI[T any, K comparable, V any](collection []T, transform func(item T, index int) (K, V)) map[K]V {
+	result := make(map[K]V, len(collection))
 
-	for _, t := range collection {
-		k, v := transform(t)
+	for index, item := range collection {
+		k, v := transform(item, index)
 		result[k] = v
 	}
 
@@ -318,40 +653,98 @@ func Associate[T any, K comparable, V any](collection []T, transform func(T) (K,
 }
 
 // SliceToMap returns a map containing key-value pairs provided by transform function applied to elements of the given slice.
-// If any of two pairs would have the same key the last one gets added to the map.
-// The order of keys in returned map is not specified and is not guaranteed to be the same from the original array.
+// If any of two pairs have the same key the last one gets added to the map.
+// The order of keys in returned map is not specified and is not guaranteed to be the same from the original slice.
 // Alias of Associate().
 // Play: https://go.dev/play/p/WHa2CfMO3Lr
-func SliceToMap[T any, K comparable, V any](collection []T, transform func(T) (K, V)) map[K]V {
+func SliceToMap[T any, K comparable, V any](collection []T, transform func(item T) (K, V)) map[K]V {
 	return Associate(collection, transform)
 }
 
-// Drop drops n elements from the beginning of a slice or array.
+// SliceToMapI returns a map containing key-value pairs provided by transform function applied to elements of the given slice.
+// If any of two pairs have the same key the last one gets added to the map.
+// The order of keys in returned map is not specified and is not guaranteed to be the same from the original slice.
+// Alias of AssociateI().
+// Play: https://go.dev/play/p/mMBm5GV3_eq
+func SliceToMapI[T any, K comparable, V any](collection []T, transform func(item T, index int) (K, V)) map[K]V {
+	return AssociateI(collection, transform)
+}
+
+// FilterSliceToMap returns a map containing key-value pairs provided by transform function applied to elements of the given slice.
+// If any of two pairs have the same key the last one gets added to the map.
+// The order of keys in returned map is not specified and is not guaranteed to be the same from the original slice.
+// The third return value of the transform function is a boolean that indicates whether the key-value pair should be included in the map.
+// Play: https://go.dev/play/p/2z0rDz2ZSGU
+func FilterSliceToMap[T any, K comparable, V any](collection []T, transform func(item T) (K, V, bool)) map[K]V {
+	return FilterSliceToMapI(collection, func(item T, _ int) (K, V, bool) {
+		return transform(item)
+	})
+}
+
+// FilterSliceToMapI returns a map containing key-value pairs provided by transform function applied to elements of the given slice.
+// If any of two pairs have the same key the last one gets added to the map.
+// The order of keys in returned map is not specified and is not guaranteed to be the same from the original slice.
+// The third return value of the transform function is a boolean that indicates whether the key-value pair should be included in the map.
+// Play: https://go.dev/play/p/mSz_bUIk9aJ
+func FilterSliceToMapI[T any, K comparable, V any](collection []T, transform func(item T, index int) (K, V, bool)) map[K]V {
+	result := make(map[K]V, len(collection))
+
+	for index, item := range collection {
+		k, v, ok := transform(item, index)
+		if ok {
+			result[k] = v
+		}
+	}
+
+	return result
+}
+
+// Keyify returns a map with each unique element of the slice as a key.
+// Play: https://go.dev/play/p/RYhhM_csqIG
+func Keyify[T comparable, Slice ~[]T](collection Slice) map[T]struct{} {
+	result := make(map[T]struct{}, len(collection))
+
+	for i := range collection {
+		result[collection[i]] = struct{}{}
+	}
+
+	return result
+}
+
+// Drop drops n elements from the beginning of a slice.
 // Play: https://go.dev/play/p/JswS7vXRJP2
-func Drop[T any](collection []T, n int) []T {
+func Drop[T any, Slice ~[]T](collection Slice, n int) Slice {
+	if n < 0 {
+		panic("lo.Drop: n must not be negative")
+	}
+
 	if len(collection) <= n {
-		return make([]T, 0)
+		return make(Slice, 0)
 	}
 
-	result := make([]T, 0, len(collection)-n)
+	result := make(Slice, 0, len(collection)-n)
 
 	return append(result, collection[n:]...)
 }
 
-// DropRight drops n elements from the end of a slice or array.
+// DropRight drops n elements from the end of a slice.
 // Play: https://go.dev/play/p/GG0nXkSJJa3
-func DropRight[T any](collection []T, n int) []T {
+func DropRight[T any, Slice ~[]T](collection Slice, n int) Slice {
+	if n < 0 {
+		panic("lo.DropRight: n must not be negative")
+	}
+
 	if len(collection) <= n {
-		return []T{}
+		return Slice{}
 	}
 
-	result := make([]T, 0, len(collection)-n)
+	result := make(Slice, 0, len(collection)-n)
 	return append(result, collection[:len(collection)-n]...)
 }
 
-// DropWhile drops elements from the beginning of a slice or array while the predicate returns true.
+// DropWhile drops elements from the beginning of a slice while the predicate returns true.
 // Play: https://go.dev/play/p/7gBPYw2IK16
-func DropWhile[T any](collection []T, predicate func(T) bool) []T {
+func DropWhile[T any, Slice ~[]T](collection Slice, predicate func(item T) bool) Slice {
 	i := 0
 	for ; i < len(collection); i++ {
 		if !predicate(collection[i]) {
@@ -359,13 +752,13 @@ func DropWhile[T any](collection []T, predicate func(T) bool) []T {
 		}
 	}
 
-	result := make([]T, 0, len(collection)-i)
+	result := make(Slice, 0, len(collection)-i)
 	return append(result, collection[i:]...)
 }
 
-// DropRightWhile drops elements from the end of a slice or array while the predicate returns true.
+// DropRightWhile drops elements from the end of a slice while the predicate returns true.
 // Play: https://go.dev/play/p/3-n71oEC0Hz
-func DropRightWhile[T any](collection []T, predicate func(T) bool) []T {
+func DropRightWhile[T any, Slice ~[]T](collection Slice, predicate func(item T) bool) Slice {
 	i := len(collection) - 1
 	for ; i >= 0; i-- {
 		if !predicate(collection[i]) {
@@ -373,29 +766,193 @@ func DropRightWhile[T any](collection []T, predicate func(T) bool) []T {
 		}
 	}
 
-	result := make([]T, 0, i+1)
+	result := make(Slice, 0, i+1)
 	return append(result, collection[:i+1]...)
 }
 
-// Reject is the opposite of Filter, this method returns the elements of collection that predicate does not return truthy for.
-// Play: https://go.dev/play/p/YkLMODy1WEL
-func Reject[V any](collection []V, predicate func(V, int) bool) []V {
-	result := []V{}
+// Take takes the first n elements from a slice.
+func Take[T any, Slice ~[]T](collection Slice, n int) Slice {
+	if n < 0 {
+		panic("lo.Take: n must not be negative")
+	}
+
+	if n == 0 {
+		return make(Slice, 0)
+	}
+
+	size := len(collection)
+	if size == 0 {
+		return make(Slice, 0)
+	}
+
+	if n >= size {
+		result := make(Slice, size)
+		copy(result, collection)
+		return result
+	}
+
+	result := make(Slice, n)
+	copy(result, collection)
+	return result
+}
 
-	for i, item := range collection {
-		if !predicate(item, i) {
-			result = append(result, item)
+// TakeWhile takes elements from the beginning of a slice while the predicate returns true.
+func TakeWhile[T any, Slice ~[]T](collection Slice, predicate func(item T) bool) Slice {
+	i := 0
+	for ; i < len(collection); i++ {
+		if !predicate(collection[i]) {
+			break
 		}
 	}
 
+	result := make(Slice, i)
+	copy(result, collection[:i])
 	return result
 }
 
-// Count counts the number of elements in the collection that compare equal to value.
+// DropByIndex drops elements from a slice by the index.
+// A negative index will drop elements from the end of the slice.
+// Play: https://go.dev/play/p/bPIH4npZRxS
+func DropByIndex[T any, Slice ~[]T](collection Slice, indexes ...int) Slice {
+	initialSize := len(collection)
+	if initialSize == 0 {
+		return Slice{}
+	}
+
+	// do not change the input
+	indexes = append(make([]int, 0, len(indexes)), indexes...)
+
+	for i, index := range indexes {
+		if index < 0 {
+			indexes[i] += initialSize
+		}
+	}
+
+	sort.Ints(indexes)
+
+	prev := -1
+	indexes = mutable.Filter(indexes, func(index int) bool {
+		ok := index != prev && // uniq
+			uint(index) < uint(initialSize) // in range
+
+		prev = index
+		return ok
+	})
+
+	result := make(Slice, 0, initialSize-len(indexes))
+
+	i := 0
+	for _, index := range indexes {
+		result = append(result, collection[i:index]...)
+		i = index + 1
+	}
+
+	return append(result, collection[i:]...)
+}
+
+// TakeFilter filters elements and takes the first n elements that match the predicate.
+// Equivalent to calling Take(Filter(...)), but more efficient as it stops after finding n matches.
+func TakeFilter[T any, Slice ~[]T](collection Slice, n int, predicate func(item T, index int) bool) Slice {
+	if n < 0 {
+		panic("lo.TakeFilter: n must not be negative")
+	}
+
+	if n == 0 {
+		return make(Slice, 0)
+	}
+
+	result := make(Slice, 0, n)
+	count := 0
+
+	for i := range collection {
+		if predicate(collection[i], i) {
+			result = append(result, collection[i])
+			count++
+			if count >= n {
+				break
+			}
+		}
+	}
+
+	return result
+}
+
+// Reject is the opposite of Filter, this method returns the elements of collection that predicate does not return true for.
+// Play: https://go.dev/play/p/pFCF5WVB225
+func Reject[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) bool) Slice {
+	result := Slice{}
+
+	for i := range collection {
+		if !predicate(collection[i], i) {
+			result = append(result, collection[i])
+		}
+	}
+
+	return result
+}
+
+// RejectErr is the opposite of FilterErr, this method returns the elements of collection that predicate does not return true for.
+// If the predicate returns an error, iteration stops immediately and returns the error.
+// Play: https://go.dev/play/p/pFCF5WVB225
+func RejectErr[T any, Slice ~[]T](collection Slice, predicate func(item T, index int) (bool, error)) (Slice, error) {
+	result := Slice{}
+
+	for i := range collection {
+		match, err := predicate(collection[i], i)
+		if err != nil {
+			return nil, err
+		}
+		if !match {
+			result = append(result, collection[i])
+		}
+	}
+
+	return result, nil
+}
+
+// RejectMap is the opposite of FilterMap, this method returns a slice obtained after both filtering and mapping using the given callback function.
+// The callback function should return two values:
+//   - the result of the mapping operation and
+//   - whether the result element should be included or not.
+//
+// Play: https://go.dev/play/p/W9Ug9r0QFkL
+func RejectMap[T, R any](collection []T, callback func(item T, index int) (R, bool)) []R {
+	result := []R{}
+
+	for i := range collection {
+		if r, ok := callback(collection[i], i); !ok {
+			result = append(result, r)
+		}
+	}
+
+	return result
+}
+
+// FilterReject mixes Filter and Reject, this method returns two slices, one for the elements of collection that
+// predicate returns true for and one for the elements that predicate does not return true for.
+// Play: https://go.dev/play/p/lHSEGSznJjB
+func FilterReject[T any, Slice ~[]T](collection Slice, predicate func(T, int) bool) (kept, rejected Slice) {
+	kept = make(Slice, 0, len(collection))
+	rejected = make(Slice, 0, len(collection))
+
+	for i := range collection {
+		if predicate(collection[i], i) {
+			kept = append(kept, collection[i])
+		} else {
+			rejected = append(rejected, collection[i])
+		}
+	}
+
+	return kept, rejected
+}
+
+// Count counts the number of elements in the collection that equal value.
 // Play: https://go.dev/play/p/Y3FlK54yveC
-func Count[T comparable](collection []T, value T) (count int) {
-	for _, item := range collection {
-		if item == value {
+func Count[T comparable](collection []T, value T) int {
+	var count int
+
+	for i := range collection {
+		if collection[i] == value {
 			count++
 		}
 	}
@@ -405,9 +962,11 @@ func Count[T comparable](collection []T, value T) (count int) {
 
 // CountBy counts the number of elements in the collection for which predicate is true.
 // Play: https://go.dev/play/p/ByQbNYQQi4X
-func CountBy[T any](collection []T, predicate func(T) bool) (count int) {
-	for _, item := range collection {
-		if predicate(item) {
+func CountBy[T any](collection []T, predicate func(item T) bool) int {
+	var count int
+
+	for i := range collection {
+		if predicate(collection[i]) {
 			count++
 		}
 	}
@@ -415,9 +974,52 @@ func CountBy[T any](collection []T, predicate func(T) bool) (count int) {
 	return count
 }
 
+// CountByErr counts the number of elements in the collection for which predicate is true.
+// It returns the first error returned by the predicate.
+func CountByErr[T any](collection []T, predicate func(item T) (bool, error)) (int, error) {
+	var count int
+
+	for i := range collection {
+		ok, err := predicate(collection[i])
+		if err != nil {
+			return 0, err
+		}
+		if ok {
+			count++
+		}
+	}
+
+	return count, nil
+}
+
+// CountValues counts the number of each element in the collection.
+// Play: https://go.dev/play/p/-p-PyLT4dfy
+func CountValues[T comparable](collection []T) map[T]int {
+	result := make(map[T]int)
+
+	for i := range collection {
+		result[collection[i]]++
+	}
+
+	return result
+}
+
+// CountValuesBy counts the number of each element returned from transform function.
+// Is equivalent to chaining lo.Map and lo.CountValues.
+// Play: https://go.dev/play/p/2U0dG1SnOmS
+func CountValuesBy[T any, U comparable](collection []T, transform func(item T) U) map[U]int {
+	result := make(map[U]int)
+
+	for i := range collection {
+		result[transform(collection[i])]++
+	}
+
+	return result
+}
+
 // Subset returns a copy of a slice from `offset` up to `length` elements. Like `slice[start:start+length]`, but does not panic on overflow.
 // Play: https://go.dev/play/p/tOQu1GhFcog
-func Subset[T any](collection []T, offset int, length uint) []T {
+func Subset[T any, Slice ~[]T](collection Slice, offset int, length uint) Slice {
 	size := len(collection)
 
 	if offset < 0 {
@@ -428,7 +1030,7 @@ func Subset[T any](collection []T, offset int, length uint) []T {
 	}
 
 	if offset > size {
-		return []T{}
+		return Slice{}
 	}
 
 	if length > uint(size)-uint(offset) {
@@ -438,20 +1040,23 @@ func Subset[T any](collection []T, offset int, length uint) []T {
 	return collection[offset : offset+int(length)]
 }
 
-// Slice returns a copy of a slice from `start` up to, but not including `end`. Like `slice[start:end]`, but does not panic on overflow.
+// Slice returns a slice from `start` up to, but not including `end`. Like `slice[start:end]`, but does not panic on overflow.
 // Play: https://go.dev/play/p/8XWYhfMMA1h
-func Slice[T any](collection []T, start int, end int) []T {
-	size := len(collection)
-
+func Slice[T any, Slice ~[]T](collection Slice, start, end int) Slice {
 	if start >= end {
-		return []T{}
+		return Slice{}
 	}
 
-	if start > size {
+	size := len(collection)
+	if start < 0 {
+		start = 0
+	} else if start > size {
 		start = size
 	}
 
-	if end > size {
+	if end < 0 {
+		end = 0
+	} else if end > size {
 		end = size
 	}
 
@@ -460,13 +1065,13 @@ func Slice[T any](collection []T, start int, end int) []T {
 
 // Replace returns a copy of the slice with the first n non-overlapping instances of old replaced by new.
 // Play: https://go.dev/play/p/XfPzmf9gql6
-func Replace[T comparable](collection []T, old T, new T, n int) []T {
-	result := make([]T, len(collection))
+func Replace[T comparable, Slice ~[]T](collection Slice, old, nEw T, n int) Slice {
+	result := make(Slice, len(collection))
 	copy(result, collection)
 
 	for i := range result {
 		if result[i] == old && n != 0 {
-			result[i] = new
+			result[i] = nEw
 			n--
 		}
 	}
@@ -476,20 +1081,34 @@ func Replace[T comparable](collection []T, old T, new T, n int) []T {
 
 // ReplaceAll returns a copy of the slice with all non-overlapping instances of old replaced by new.
 // Play: https://go.dev/play/p/a9xZFUHfYcV
-func ReplaceAll[T comparable](collection []T, old T, new T) []T {
-	return Replace(collection, old, new, -1)
+func ReplaceAll[T comparable, Slice ~[]T](collection Slice, old, nEw T) Slice {
+	return Replace(collection, old, nEw, -1)
+}
+
+// Clone returns a shallow copy of the collection.
+func Clone[T any, Slice ~[]T](collection Slice) Slice {
+	// backporting from slices.Clone in Go 1.21
+	// when we drop support for Go 1.20, this can be replaced with: return slices.Clone(collection)
+
+	// Preserve nilness in case it matters.
+	if collection == nil {
+		return nil
+	}
+	// Avoid s[:0:0] as it leads to unwanted liveness when cloning a
+	// zero-length slice of a large array; see https://go.dev/issue/68488.
+	return append(Slice{}, collection...)
 }
 
 // Compact returns a slice of all non-zero elements.
 // Play: https://go.dev/play/p/tXiy-iK6PAc
-func Compact[T comparable](collection []T) []T {
+func Compact[T comparable, Slice ~[]T](collection Slice) Slice {
 	var zero T
 
-	result := []T{}
+	result := make(Slice, 0, len(collection))
 
-	for _, item := range collection {
-		if item != zero {
-			result = append(result, item)
+	for i := range collection {
+		if collection[i] != zero {
+			result = append(result, collection[i])
 		}
 	}
 
@@ -508,9 +1127,8 @@ func IsSorted[T constraints.Ordered](collection []T) bool {
 	return true
 }
 
-// IsSortedByKey checks if a slice is sorted by iteratee.
-// Play: https://go.dev/play/p/wiG6XyBBu49
-func IsSortedByKey[T any, K constraints.Ordered](collection []T, iteratee func(T) K) bool {
+// IsSortedBy checks if a slice is sorted by iteratee.
+func IsSortedBy[T any, K constraints.Ordered](collection []T, iteratee func(item T) K) bool {
 	size := len(collection)
 
 	for i := 0; i < size-1; i++ {
@@ -521,3 +1139,160 @@ func IsSortedByKey[T any, K constraints.Ordered](collection []T, iteratee func(T
 
 	return true
 }
+
+// IsSortedByKey checks if a slice is sorted by iteratee.
+//
+// Deprecated: Use lo.IsSortedBy instead.
+func IsSortedByKey[T any, K constraints.Ordered](collection []T, iteratee func(item T) K) bool {
+	return IsSortedBy(collection, iteratee)
+}
+
+// Splice inserts multiple elements at index i. A negative index counts back
+// from the end of the slice. The helper is protected against overflow errors.
+// Play: https://go.dev/play/p/G5_GhkeSUBA
+func Splice[T any, Slice ~[]T](collection Slice, i int, elements ...T) Slice {
+	sizeCollection := len(collection)
+	sizeElements := len(elements)
+	output := make(Slice, 0, sizeCollection+sizeElements) // preallocate memory for the output slice
+
+	switch {
+	case sizeElements == 0:
+		return append(output, collection...) // simple copy
+	case i > sizeCollection:
+		// positive overflow
+		return append(append(output, collection...), elements...)
+	case i < -sizeCollection:
+		// negative overflow
+		return append(append(output, elements...), collection...)
+	case i < 0:
+		// backward
+		i = sizeCollection + i
+	}
+
+	return append(append(append(output, collection[:i]...), elements...), collection[i:]...)
+}
+
+// Cut slices collection around the first instance of separator, returning the part of collection
+// before and after separator. The found result reports whether separator appears in collection.
+// If separator does not appear in s, cut returns collection, empty slice of []T, false.
+// Play: https://go.dev/play/p/GiL3qhpIP3f
+func Cut[T comparable, Slice ~[]T](collection, separator Slice) (before, after Slice, found bool) {
+	if len(separator) == 0 {
+		return make(Slice, 0), collection, true
+	}
+
+	for i := 0; i+len(separator) <= len(collection); i++ {
+		match := true
+		for j := 0; j < len(separator); j++ {
+			if collection[i+j] != separator[j] {
+				match = false
+				break
+			}
+		}
+		if match {
+			return collection[:i], collection[i+len(separator):], true
+		}
+	}
+
+	return collection, make(Slice, 0), false
+}
+
+// CutPrefix returns collection without the provided leading prefix []T
+// and reports whether it found the prefix.
+// If s doesn't start with prefix, CutPrefix returns collection, false.
+// If prefix is the empty []T, CutPrefix returns collection, true.
+// Play: https://go.dev/play/p/7Plak4a1ICl
+func CutPrefix[T comparable, Slice ~[]T](collection, separator Slice) (after Slice, found bool) {
+	if HasPrefix(collection, separator) {
+		return collection[len(separator):], true
+	}
+	return collection, false
+}
+
+// CutSuffix returns collection without the provided ending suffix []T and reports
+// whether it found the suffix. If s doesn't end with suffix, CutSuffix returns collection, false.
+// If suffix is the empty []T, CutSuffix returns collection, true.
+// Play: https://go.dev/play/p/7FKfBFvPTaT
+func CutSuffix[T comparable, Slice ~[]T](collection, separator Slice) (before Slice, found bool) {
+	if HasSuffix(collection, separator) {
+		return collection[:len(collection)-len(separator)], true
+	}
+	return collection, false
+}
+
+// Trim removes all the leading and trailing cutset from the collection.
+// Play: https://go.dev/play/p/1an9mxLdRG5
+func Trim[T comparable, Slice ~[]T](collection, cutset Slice) Slice {
+	set := Keyify(cutset)
+
+	i := 0
+	for ; i < len(collection); i++ {
+		if _, ok := set[collection[i]]; !ok {
+			break
+		}
+	}
+
+	if i >= len(collection) {
+		return Slice{}
+	}
+
+	j := len(collection) - 1
+	for ; j >= 0; j-- {
+		if _, ok := set[collection[j]]; !ok {
+			break
+		}
+	}
+
+	result := make(Slice, 0, j+1-i)
+	return append(result, collection[i:j+1]...)
+}
+
+// TrimLeft removes all the leading cutset from the collection.
+// Play: https://go.dev/play/p/74aqfAYLmyi
+func TrimLeft[T comparable, Slice ~[]T](collection, cutset Slice) Slice {
+	set := Keyify(cutset)
+
+	return DropWhile(collection, func(item T) bool {
+		_, ok := set[item]
+		return ok
+	})
+}
+
+// TrimPrefix removes all the leading prefix from the collection.
+// Play: https://go.dev/play/p/SHO6X-YegPg
+func TrimPrefix[T comparable, Slice ~[]T](collection, prefix Slice) Slice {
+	if len(prefix) == 0 {
+		return collection
+	}
+
+	for HasPrefix(collection, prefix) {
+		collection = collection[len(prefix):]
+	}
+
+	return collection
+}
+
+// TrimRight removes all the trailing cutset from the collection.
+// Play: https://go.dev/play/p/MRpAfR6sf0g
+func TrimRight[T comparable, Slice ~[]T](collection, cutset Slice) Slice {
+	set := Keyify(cutset)
+
+	return DropRightWhile(collection, func(item T) bool {
+		_, ok := set[item]
+		return ok
+	})
+}
+
+// TrimSuffix removes all the trailing suffix from the collection.
+// Play: https://go.dev/play/p/IjEUrV0iofq
+func TrimSuffix[T comparable, Slice ~[]T](collection, suffix Slice) Slice {
+	if len(suffix) == 0 {
+		return collection
+	}
+
+	for HasSuffix(collection, suffix) {
+		collection = collection[:len(collection)-len(suffix)]
+	}
+
+	return collection
+}
diff --git a/vendor/github.com/samber/lo/string.go b/vendor/github.com/samber/lo/string.go
index a63167cb134..9b0fc6e9557 100644
--- a/vendor/github.com/samber/lo/string.go
+++ b/vendor/github.com/samber/lo/string.go
@@ -1,49 +1,211 @@
 package lo
 
 import (
+	"math"
+	"regexp"
+	"strings"
+	"unicode"
 	"unicode/utf8"
+
+	"golang.org/x/text/cases"
+	"golang.org/x/text/language"
+
+	"github.com/samber/lo/internal/xrand"
 )
 
-// Substring return part of a string.
-// Play: https://go.dev/play/p/TQlxQi82Lu1
-func Substring[T ~string](str T, offset int, length uint) T {
-	size := len(str)
+var (
+	//nolint:revive
+	LowerCaseLettersCharset = []rune("abcdefghijklmnopqrstuvwxyz")
+	UpperCaseLettersCharset = []rune("ABCDEFGHIJKLMNOPQRSTUVWXYZ")
+	LettersCharset          = append(LowerCaseLettersCharset, UpperCaseLettersCharset...)
+	NumbersCharset          = []rune("0123456789")
+	AlphanumericCharset     = append(LettersCharset, NumbersCharset...)
+	SpecialCharset          = []rune("!@#$%^&*()_+-=[]{}|;':\",./<>?")
+	AllCharset              = append(AlphanumericCharset, SpecialCharset...)
+
+	// bearer:disable go_lang_permissive_regex_validation
+	splitWordReg = regexp.MustCompile(`([a-z])([A-Z0-9])|([a-zA-Z])([0-9])|([0-9])([a-zA-Z])|([A-Z])([A-Z])([a-z])`)
+	// bearer:disable go_lang_permissive_regex_validation
+	splitNumberLetterReg = regexp.MustCompile(`([0-9])([a-zA-Z])`)
+	maximumCapacity      = math.MaxInt>>1 + 1
+)
+
+// RandomString return a random string.
+// Play: https://go.dev/play/p/rRseOQVVum4
+func RandomString(size int, charset []rune) string {
+	if size <= 0 {
+		panic("lo.RandomString: size must be greater than 0")
+	}
+	if len(charset) == 0 {
+		panic("lo.RandomString: charset must not be empty")
+	}
 
-	if offset < 0 {
-		offset = size + offset
-		if offset < 0 {
-			offset = 0
+	// see https://stackoverflow.com/questions/22892120/how-to-generate-a-random-string-of-a-fixed-length-in-go
+	var sb strings.Builder
+	sb.Grow(size)
+
+	if len(charset) == 1 {
+		// Edge case, because if the charset is a single character,
+		// it will panic below (divide by zero).
+		// -> https://github.com/samber/lo/issues/679
+		for i := 0; i < size; i++ {
+			sb.WriteRune(charset[0])
 		}
+		return sb.String()
 	}
 
-	if offset > size {
-		return Empty[T]()
+	// Calculate the number of bits required to represent the charset,
+	// e.g., for 62 characters, it would need 6 bits (since 62 -> 64 = 2^6)
+	letterIDBits := int(math.Log2(float64(nearestPowerOfTwo(len(charset)))))
+	// Determine the corresponding bitmask,
+	// e.g., for 62 characters, the bitmask would be 111111.
+	var letterIDMask int64 = 1<<letterIDBits - 1
+	// Available count, since xrand.Int64() returns a non-negative number, the first bit is fixed, so there are 63 random bits
+	// e.g., for 62 characters, this value is 10 (63 / 6).
+	letterIDMax := 63 / letterIDBits
+	// Generate the random string in a loop.
+	for i, cache, remain := size-1, xrand.Int64(), letterIDMax; i >= 0; {
+		// Regenerate the random number if all available bits have been used
+		if remain == 0 {
+			cache, remain = xrand.Int64(), letterIDMax
+		}
+		// Select a character from the charset
+		if idx := int(cache & letterIDMask); idx < len(charset) {
+			sb.WriteRune(charset[idx])
+			i--
+		}
+		// Shift the bits to the right to prepare for the next character selection,
+		// e.g., for 62 characters, shift by 6 bits.
+		cache >>= letterIDBits
+		// Decrease the remaining number of uses for the current random number.
+		remain--
 	}
+	return sb.String()
+}
 
-	if length > uint(size)-uint(offset) {
-		length = uint(size - offset)
+// nearestPowerOfTwo returns the nearest power of two.
+func nearestPowerOfTwo(capacity int) int {
+	n := capacity - 1
+	n |= n >> 1
+	n |= n >> 2
+	n |= n >> 4
+	n |= n >> 8
+	n |= n >> 16
+	if n < 0 {
+		return 1
+	}
+	if n >= maximumCapacity {
+		return maximumCapacity
 	}
+	return n + 1
+}
+
+// Substring extracts a substring from a string with Unicode character (rune) awareness.
+// offset - starting position of the substring (can be positive, negative, or zero)
+// length - number of characters to extract
+// With positive offset, counting starts from the beginning of the string
+// With negative offset, counting starts from the end of the string
+// Play: https://go.dev/play/p/TQlxQi82Lu1
+func Substring[T ~string](str T, offset int, length uint) T {
+	str = substring(str, offset, length)
 
-	return str[offset : offset+int(length)]
+	// Validate UTF-8 and fix invalid sequences
+	if !utf8.ValidString(string(str)) {
+		// Convert to []rune to replicate behavior with duplicated �
+		str = T([]rune(str))
+	}
+
+	// Remove null bytes from result
+	return T(strings.ReplaceAll(string(str), "\x00", ""))
 }
 
-// ChunkString returns an array of strings split into groups the length of size. If array can't be split evenly,
-// the final chunk will be the remaining elements.
+func substring[T ~string](str T, offset int, length uint) T {
+	switch {
+	// Empty length or offset beyond string bounds - return empty string
+	case length == 0, offset >= len(str):
+		return ""
+
+	// Positive offset - count from the beginning
+	case offset > 0:
+		// Skip offset runes from the start
+		for i, r := range str {
+			if offset--; offset == 0 {
+				str = str[i+utf8.RuneLen(r):]
+				break
+			}
+		}
+
+		// If couldn't skip enough runes - string is shorter than offset
+		if offset != 0 {
+			return ""
+		}
+
+		// If remaining string is shorter than or equal to length - return it entirely
+		if uint(len(str)) <= length {
+			return str
+		}
+
+		// Otherwise proceed to trimming by length
+		fallthrough
+
+	// Zero offset or offset less than minus string length - start from beginning
+	case offset < -len(str), offset == 0:
+		// Count length runes from the start
+		for i := range str {
+			if length == 0 {
+				return str[:i]
+			}
+			length--
+		}
+
+		return str
+
+	// Negative offset - count from the end of string
+	default: // -len(str) < offset < 0
+		// Helper function to move backward through runes
+		backwardPos := func(end int, count uint) (start int) {
+			for {
+				_, i := utf8.DecodeLastRuneInString(string(str[:end]))
+				end -= i
+
+				if count--; count == 0 || end == 0 {
+					return end
+				}
+			}
+		}
+
+		offset := uint(-offset)
+
+		// If offset is less than or equal to length - take from position to end
+		if offset <= length {
+			start := backwardPos(len(str), offset)
+			return str[start:]
+		}
+
+		// Otherwise calculate start and end positions
+		end := backwardPos(len(str), offset-length)
+		start := backwardPos(end, length)
+
+		return str[start:end]
+	}
+}
+
+// ChunkString returns a slice of strings split into groups of length size. If the string can't be split evenly,
+// the final chunk will be the remaining characters.
 // Play: https://go.dev/play/p/__FLTuJVz54
+//
+// Note: lo.ChunkString and lo.Chunk functions behave inconsistently for empty input: lo.ChunkString("", n) returns [""] instead of [].
+// See https://github.com/samber/lo/issues/788
 func ChunkString[T ~string](str T, size int) []T {
 	if size <= 0 {
-		panic("lo.ChunkString: Size parameter must be greater than 0")
-	}
-
-	if len(str) == 0 {
-		return []T{""}
+		panic("lo.ChunkString: size must be greater than 0")
 	}
 
 	if size >= len(str) {
 		return []T{str}
 	}
 
-	var chunks []T = make([]T, 0, ((len(str)-1)/size)+1)
+	chunks := make([]T, 0, ((len(str)-1)/size)+1)
 	currentLen := 0
 	currentStart := 0
 	for i := range str {
@@ -63,3 +225,94 @@ func ChunkString[T ~string](str T, size int) []T {
 func RuneLength(str string) int {
 	return utf8.RuneCountInString(str)
 }
+
+// PascalCase converts string to pascal case.
+// Play: https://go.dev/play/p/Dy_V_6DUYhe
+func PascalCase(str string) string {
+	items := Words(str)
+	for i := range items {
+		items[i] = Capitalize(items[i])
+	}
+	return strings.Join(items, "")
+}
+
+// CamelCase converts string to camel case.
+// Play: https://go.dev/play/p/Go6aKwUiq59
+func CamelCase(str string) string {
+	items := Words(str)
+	for i, item := range items {
+		item = strings.ToLower(item)
+		if i > 0 {
+			item = Capitalize(item)
+		}
+		items[i] = item
+	}
+	return strings.Join(items, "")
+}
+
+// KebabCase converts string to kebab case.
+// Play: https://go.dev/play/p/96gT_WZnTVP
+func KebabCase(str string) string {
+	items := Words(str)
+	for i := range items {
+		items[i] = strings.ToLower(items[i])
+	}
+	return strings.Join(items, "-")
+}
+
+// SnakeCase converts string to snake case.
+// Play: https://go.dev/play/p/ziB0V89IeVH
+func SnakeCase(str string) string {
+	items := Words(str)
+	for i := range items {
+		items[i] = strings.ToLower(items[i])
+	}
+	return strings.Join(items, "_")
+}
+
+// Words splits string into a slice of its words.
+// Play: https://go.dev/play/p/-f3VIQqiaVw
+func Words(str string) []string {
+	str = splitWordReg.ReplaceAllString(str, `$1$3$5$7 $2$4$6$8$9`)
+	// example: Int8Value => Int 8Value => Int 8 Value
+	str = splitNumberLetterReg.ReplaceAllString(str, "$1 $2")
+	var result strings.Builder
+	result.Grow(len(str))
+	for _, r := range str {
+		if unicode.IsLetter(r) || unicode.IsDigit(r) {
+			result.WriteRune(r)
+		} else {
+			result.WriteRune(' ')
+		}
+	}
+	return strings.Fields(result.String())
+}
+
+// Capitalize converts the first character of string to upper case and the remaining to lower case.
+// Play: https://go.dev/play/p/uLTZZQXqnsa
+func Capitalize(str string) string {
+	return cases.Title(language.English).String(str)
+}
+
+// Ellipsis trims and truncates a string to a specified length in runes and appends an ellipsis
+// if truncated. The length parameter counts Unicode code points (runes), not bytes, so multi-byte
+// characters such as emoji or CJK ideographs are never split in the middle.
+// Play: https://go.dev/play/p/qE93rgqe1TW
+func Ellipsis(str string, length int) string {
+	str = strings.TrimSpace(str)
+
+	const ellipsis = "..."
+
+	cutPosition := 0
+	for i := range str {
+		if length == len(ellipsis) {
+			cutPosition = i
+		}
+
+		if length--; length < 0 {
+			return strings.TrimSpace(str[:cutPosition]) + ellipsis
+		}
+	}
+
+	return str
+}
diff --git a/vendor/github.com/samber/lo/test.go b/vendor/github.com/samber/lo/test.go
deleted file mode 100644
index 26db4c25848..00000000000
--- a/vendor/github.com/samber/lo/test.go
+++ /dev/null
@@ -1,32 +0,0 @@
-package lo
-
-import (
-	"os"
-	"testing"
-	"time"
-)
-
-// https://github.com/stretchr/testify/issues/1101
-func testWithTimeout(t *testing.T, timeout time.Duration) {
-	t.Helper()
-
-	testFinished := make(chan struct{})
-	t.Cleanup(func() { close(testFinished) })
-
-	go func() {
-		select {
-		case <-testFinished:
-		case <-time.After(timeout):
-			t.Errorf("test timed out after %s", timeout)
-			os.Exit(1)
-		}
-	}()
-}
-
-type foo struct {
-	bar string
-}
-
-func (f foo) Clone() foo {
-	return foo{f.bar}
-}
diff --git a/vendor/github.com/samber/lo/time.go b/vendor/github.com/samber/lo/time.go
new file mode 100644
index 00000000000..a2b1c7e0552
--- /dev/null
+++ b/vendor/github.com/samber/lo/time.go
@@ -0,0 +1,99 @@
+package lo
+
+import (
+	"time"
+)
+
+// Duration returns the time taken to execute a function.
+// Play: https://go.dev/play/p/HQfbBbAXaFP
+func Duration(callback func()) time.Duration {
+	return Duration0(callback)
+}
+
+// Duration0 returns the time taken to execute a function.
+// Play: https://go.dev/play/p/HQfbBbAXaFP
+func Duration0(callback func()) time.Duration {
+	start := time.Now()
+	callback()
+	return time.Since(start)
+}
+
+// Duration1 returns the time taken to execute a function.
+// Play: https://go.dev/play/p/HQfbBbAXaFP
+func Duration1[A any](callback func() A) (A, time.Duration) {
+	start := time.Now()
+	a := callback()
+	return a, time.Since(start)
+}
+
+// Duration2 returns the time taken to execute a function.
+// Play: https://go.dev/play/p/HQfbBbAXaFP
+func Duration2[A, B any](callback func() (A, B)) (A, B, time.Duration) {
+	start := time.Now()
+	a, b := callback()
+	return a, b, time.Since(start)
+}
+
+// Duration3 returns the time taken to execute a function.
+// Play: https://go.dev/play/p/xr863iwkAxQ
+func Duration3[A, B, C any](callback func() (A, B, C)) (A, B, C, time.Duration) {
+	start := time.Now()
+	a, b, c := callback()
+	return a, b, c, time.Since(start)
+}
+
+// Duration4 returns the time taken to execute a function.
+// Play: https://go.dev/play/p/xr863iwkAxQ
+func Duration4[A, B, C, D any](callback func() (A, B, C, D)) (A, B, C, D, time.Duration) {
+	start := time.Now()
+	a, b, c, d := callback()
+	return a, b, c, d, time.Since(start)
+}
+
+// Duration5 returns the time taken to execute a function.
+// Play: https://go.dev/play/p/xr863iwkAxQ
+func Duration5[A, B, C, D, E any](callback func() (A, B, C, D, E)) (A, B, C, D, E, time.Duration) {
+	start := time.Now()
+	a, b, c, d, e := callback()
+	return a, b, c, d, e, time.Since(start)
+}
+
+// Duration6 returns the time taken to execute a function.
+// Play: https://go.dev/play/p/mR4bTQKO-Tf
+func Duration6[A, B, C, D, E, F any](callback func() (A, B, C, D, E, F)) (A, B, C, D, E, F, time.Duration) {
+	start := time.Now()
+	a, b, c, d, e, f := callback()
+	return a, b, c, d, e, f, time.Since(start)
+}
+
+// Duration7 returns the time taken to execute a function.
+// Play: https://go.dev/play/p/jgIAcBWWInS
+func Duration7[A, B, C, D, E, F, G any](callback func() (A, B, C, D, E, F, G)) (A, B, C, D, E, F, G, time.Duration) {
+	start := time.Now()
+	a, b, c, d, e, f, g := callback()
+	return a, b, c, d, e, f, g, time.Since(start)
+}
+
+// Duration8 returns the time taken to execute a function.
+// Play: https://go.dev/play/p/T8kxpG1c5Na
+func Duration8[A, B, C, D, E, F, G, H any](callback func() (A, B, C, D, E, F, G, H)) (A, B, C, D, E, F, G, H, time.Duration) {
+	start := time.Now()
+	a, b, c, d, e, f, g, h := callback()
+	return a, b, c, d, e, f, g, h, time.Since(start)
+}
+
+// Duration9 returns the time taken to execute a function.
+// Play: https://go.dev/play/p/bg9ix2VrZ0j
+func Duration9[A, B, C, D, E, F, G, H, I any](callback func() (A, B, C, D, E, F, G, H, I)) (A, B, C, D, E, F, G, H, I, time.Duration) {
+	start := time.Now()
+	a, b, c, d, e, f, g, h, i := callback()
+	return a, b, c, d, e, f, g, h, i, time.Since(start)
+}
+
+// Duration10 returns the time taken to execute a function.
+// Play: https://go.dev/play/p/Y3n7oJXqJbk
+func Duration10[A, B, C, D, E, F, G, H, I, J any](callback func() (A, B, C, D, E, F, G, H, I, J)) (A, B, C, D, E, F, G, H, I, J, time.Duration) {
+	start := time.Now()
+	a, b, c, d, e, f, g, h, i, j := callback()
+	return a, b, c, d, e, f, g, h, i, j, time.Since(start)
+}
diff --git a/vendor/github.com/samber/lo/tuples.go b/vendor/github.com/samber/lo/tuples.go
index f8ea2f14bb9..1911f8db580 100644
--- a/vendor/github.com/samber/lo/tuples.go
+++ b/vendor/github.com/samber/lo/tuples.go
@@ -2,390 +2,706 @@ package lo
 
 // T2 creates a tuple from a list of values.
 // Play: https://go.dev/play/p/IllL3ZO4BQm
-func T2[A any, B any](a A, b B) Tuple2[A, B] {
+func T2[A, B any](a A, b B) Tuple2[A, B] {
 	return Tuple2[A, B]{A: a, B: b}
 }
 
 // T3 creates a tuple from a list of values.
 // Play: https://go.dev/play/p/IllL3ZO4BQm
-func T3[A any, B any, C any](a A, b B, c C) Tuple3[A, B, C] {
+func T3[A, B, C any](a A, b B, c C) Tuple3[A, B, C] {
 	return Tuple3[A, B, C]{A: a, B: b, C: c}
 }
 
 // T4 creates a tuple from a list of values.
 // Play: https://go.dev/play/p/IllL3ZO4BQm
-func T4[A any, B any, C any, D any](a A, b B, c C, d D) Tuple4[A, B, C, D] {
+func T4[A, B, C, D any](a A, b B, c C, d D) Tuple4[A, B, C, D] {
 	return Tuple4[A, B, C, D]{A: a, B: b, C: c, D: d}
 }
 
 // T5 creates a tuple from a list of values.
 // Play: https://go.dev/play/p/IllL3ZO4BQm
-func T5[A any, B any, C any, D any, E any](a A, b B, c C, d D, e E) Tuple5[A, B, C, D, E] {
+func T5[A, B, C, D, E any](a A, b B, c C, d D, e E) Tuple5[A, B, C, D, E] {
 	return Tuple5[A, B, C, D, E]{A: a, B: b, C: c, D: d, E: e}
 }
 
 // T6 creates a tuple from a list of values.
 // Play: https://go.dev/play/p/IllL3ZO4BQm
-func T6[A any, B any, C any, D any, E any, F any](a A, b B, c C, d D, e E, f F) Tuple6[A, B, C, D, E, F] {
+func T6[A, B, C, D, E, F any](a A, b B, c C, d D, e E, f F) Tuple6[A, B, C, D, E, F] {
 	return Tuple6[A, B, C, D, E, F]{A: a, B: b, C: c, D: d, E: e, F: f}
 }
 
 // T7 creates a tuple from a list of values.
 // Play: https://go.dev/play/p/IllL3ZO4BQm
-func T7[A any, B any, C any, D any, E any, F any, G any](a A, b B, c C, d D, e E, f F, g G) Tuple7[A, B, C, D, E, F, G] {
+func T7[A, B, C, D, E, F, G any](a A, b B, c C, d D, e E, f F, g G) Tuple7[A, B, C, D, E, F, G] {
 	return Tuple7[A, B, C, D, E, F, G]{A: a, B: b, C: c, D: d, E: e, F: f, G: g}
 }
 
 // T8 creates a tuple from a list of values.
 // Play: https://go.dev/play/p/IllL3ZO4BQm
-func T8[A any, B any, C any, D any, E any, F any, G any, H any](a A, b B, c C, d D, e E, f F, g G, h H) Tuple8[A, B, C, D, E, F, G, H] {
+func T8[A, B, C, D, E, F, G, H any](a A, b B, c C, d D, e E, f F, g G, h H) Tuple8[A, B, C, D, E, F, G, H] {
 	return Tuple8[A, B, C, D, E, F, G, H]{A: a, B: b, C: c, D: d, E: e, F: f, G: g, H: h}
 }
 
-// T8 creates a tuple from a list of values.
+// T9 creates a tuple from a list of values.
 // Play: https://go.dev/play/p/IllL3ZO4BQm
-func T9[A any, B any, C any, D any, E any, F any, G any, H any, I any](a A, b B, c C, d D, e E, f F, g G, h H, i I) Tuple9[A, B, C, D, E, F, G, H, I] {
+func T9[A, B, C, D, E, F, G, H, I any](a A, b B, c C, d D, e E, f F, g G, h H, i I) Tuple9[A, B, C, D, E, F, G, H, I] {
 	return Tuple9[A, B, C, D, E, F, G, H, I]{A: a, B: b, C: c, D: d, E: e, F: f, G: g, H: h, I: i}
 }
 
-// Unpack2 returns values contained in tuple.
+// Unpack2 returns values contained in a tuple.
 // Play: https://go.dev/play/p/xVP_k0kJ96W
-func Unpack2[A any, B any](tuple Tuple2[A, B]) (A, B) {
+func Unpack2[A, B any](tuple Tuple2[A, B]) (A, B) {
 	return tuple.A, tuple.B
 }
 
-// Unpack3 returns values contained in tuple.
+// Unpack3 returns values contained in a tuple.
 // Play: https://go.dev/play/p/xVP_k0kJ96W
-func Unpack3[A any, B any, C any](tuple Tuple3[A, B, C]) (A, B, C) {
+func Unpack3[A, B, C any](tuple Tuple3[A, B, C]) (A, B, C) {
 	return tuple.A, tuple.B, tuple.C
 }
 
-// Unpack4 returns values contained in tuple.
+// Unpack4 returns values contained in a tuple.
 // Play: https://go.dev/play/p/xVP_k0kJ96W
-func Unpack4[A any, B any, C any, D any](tuple Tuple4[A, B, C, D]) (A, B, C, D) {
+func Unpack4[A, B, C, D any](tuple Tuple4[A, B, C, D]) (A, B, C, D) {
 	return tuple.A, tuple.B, tuple.C, tuple.D
 }
 
-// Unpack5 returns values contained in tuple.
+// Unpack5 returns values contained in a tuple.
 // Play: https://go.dev/play/p/xVP_k0kJ96W
-func Unpack5[A any, B any, C any, D any, E any](tuple Tuple5[A, B, C, D, E]) (A, B, C, D, E) {
+func Unpack5[A, B, C, D, E any](tuple Tuple5[A, B, C, D, E]) (A, B, C, D, E) {
 	return tuple.A, tuple.B, tuple.C, tuple.D, tuple.E
 }
 
-// Unpack6 returns values contained in tuple.
+// Unpack6 returns values contained in a tuple.
 // Play: https://go.dev/play/p/xVP_k0kJ96W
-func Unpack6[A any, B any, C any, D any, E any, F any](tuple Tuple6[A, B, C, D, E, F]) (A, B, C, D, E, F) {
+func Unpack6[A, B, C, D, E, F any](tuple Tuple6[A, B, C, D, E, F]) (A, B, C, D, E, F) {
 	return tuple.A, tuple.B, tuple.C, tuple.D, tuple.E, tuple.F
 }
 
-// Unpack7 returns values contained in tuple.
+// Unpack7 returns values contained in a tuple.
 // Play: https://go.dev/play/p/xVP_k0kJ96W
-func Unpack7[A any, B any, C any, D any, E any, F any, G any](tuple Tuple7[A, B, C, D, E, F, G]) (A, B, C, D, E, F, G) {
+func Unpack7[A, B, C, D, E, F, G any](tuple Tuple7[A, B, C, D, E, F, G]) (A, B, C, D, E, F, G) {
 	return tuple.A, tuple.B, tuple.C, tuple.D, tuple.E, tuple.F, tuple.G
 }
 
-// Unpack8 returns values contained in tuple.
+// Unpack8 returns values contained in a tuple.
 // Play: https://go.dev/play/p/xVP_k0kJ96W
-func Unpack8[A any, B any, C any, D any, E any, F any, G any, H any](tuple Tuple8[A, B, C, D, E, F, G, H]) (A, B, C, D, E, F, G, H) {
+func Unpack8[A, B, C, D, E, F, G, H any](tuple Tuple8[A, B, C, D, E, F, G, H]) (A, B, C, D, E, F, G, H) {
 	return tuple.A, tuple.B, tuple.C, tuple.D, tuple.E, tuple.F, tuple.G, tuple.H
 }
 
-// Unpack9 returns values contained in tuple.
+// Unpack9 returns values contained in a tuple.
 // Play: https://go.dev/play/p/xVP_k0kJ96W
-func Unpack9[A any, B any, C any, D any, E any, F any, G any, H any, I any](tuple Tuple9[A, B, C, D, E, F, G, H, I]) (A, B, C, D, E, F, G, H, I) {
+func Unpack9[A, B, C, D, E, F, G, H, I any](tuple Tuple9[A, B, C, D, E, F, G, H, I]) (A, B, C, D, E, F, G, H, I) {
 	return tuple.A, tuple.B, tuple.C, tuple.D, tuple.E, tuple.F, tuple.G, tuple.H, tuple.I
 }
 
 // Zip2 creates a slice of grouped elements, the first of which contains the first elements
-// of the given arrays, the second of which contains the second elements of the given arrays, and so on.
-// When collections have different size, the Tuple attributes are filled with zero value.
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
 // Play: https://go.dev/play/p/jujaA6GaJTp
-func Zip2[A any, B any](a []A, b []B) []Tuple2[A, B] {
-	size := Max([]int{len(a), len(b)})
-
-	result := make([]Tuple2[A, B], 0, size)
+func Zip2[A, B any](a []A, b []B) []Tuple2[A, B] {
+	size := uint(Max([]int{len(a), len(b)}))
 
-	for index := 0; index < size; index++ {
-		_a, _ := Nth(a, index)
-		_b, _ := Nth(b, index)
+	result := make([]Tuple2[A, B], size)
 
-		result = append(result, Tuple2[A, B]{
-			A: _a,
-			B: _b,
-		})
+	for index := uint(0); index < size; index++ {
+		result[index].A = NthOrEmpty(a, index)
+		result[index].B = NthOrEmpty(b, index)
 	}
 
 	return result
 }
 
 // Zip3 creates a slice of grouped elements, the first of which contains the first elements
-// of the given arrays, the second of which contains the second elements of the given arrays, and so on.
-// When collections have different size, the Tuple attributes are filled with zero value.
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
 // Play: https://go.dev/play/p/jujaA6GaJTp
-func Zip3[A any, B any, C any](a []A, b []B, c []C) []Tuple3[A, B, C] {
-	size := Max([]int{len(a), len(b), len(c)})
+func Zip3[A, B, C any](a []A, b []B, c []C) []Tuple3[A, B, C] {
+	size := uint(Max([]int{len(a), len(b), len(c)}))
 
-	result := make([]Tuple3[A, B, C], 0, size)
+	result := make([]Tuple3[A, B, C], size)
 
-	for index := 0; index < size; index++ {
-		_a, _ := Nth(a, index)
-		_b, _ := Nth(b, index)
-		_c, _ := Nth(c, index)
-
-		result = append(result, Tuple3[A, B, C]{
-			A: _a,
-			B: _b,
-			C: _c,
-		})
+	for index := uint(0); index < size; index++ {
+		result[index].A = NthOrEmpty(a, index)
+		result[index].B = NthOrEmpty(b, index)
+		result[index].C = NthOrEmpty(c, index)
 	}
 
 	return result
 }
 
 // Zip4 creates a slice of grouped elements, the first of which contains the first elements
-// of the given arrays, the second of which contains the second elements of the given arrays, and so on.
-// When collections have different size, the Tuple attributes are filled with zero value.
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
 // Play: https://go.dev/play/p/jujaA6GaJTp
-func Zip4[A any, B any, C any, D any](a []A, b []B, c []C, d []D) []Tuple4[A, B, C, D] {
-	size := Max([]int{len(a), len(b), len(c), len(d)})
-
-	result := make([]Tuple4[A, B, C, D], 0, size)
+func Zip4[A, B, C, D any](a []A, b []B, c []C, d []D) []Tuple4[A, B, C, D] {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d)}))
 
-	for index := 0; index < size; index++ {
-		_a, _ := Nth(a, index)
-		_b, _ := Nth(b, index)
-		_c, _ := Nth(c, index)
-		_d, _ := Nth(d, index)
+	result := make([]Tuple4[A, B, C, D], size)
 
-		result = append(result, Tuple4[A, B, C, D]{
-			A: _a,
-			B: _b,
-			C: _c,
-			D: _d,
-		})
+	for index := uint(0); index < size; index++ {
+		result[index].A = NthOrEmpty(a, index)
+		result[index].B = NthOrEmpty(b, index)
+		result[index].C = NthOrEmpty(c, index)
+		result[index].D = NthOrEmpty(d, index)
 	}
 
 	return result
 }
 
 // Zip5 creates a slice of grouped elements, the first of which contains the first elements
-// of the given arrays, the second of which contains the second elements of the given arrays, and so on.
-// When collections have different size, the Tuple attributes are filled with zero value.
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
 // Play: https://go.dev/play/p/jujaA6GaJTp
-func Zip5[A any, B any, C any, D any, E any](a []A, b []B, c []C, d []D, e []E) []Tuple5[A, B, C, D, E] {
-	size := Max([]int{len(a), len(b), len(c), len(d), len(e)})
+func Zip5[A, B, C, D, E any](a []A, b []B, c []C, d []D, e []E) []Tuple5[A, B, C, D, E] {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d), len(e)}))
 
-	result := make([]Tuple5[A, B, C, D, E], 0, size)
+	result := make([]Tuple5[A, B, C, D, E], size)
 
-	for index := 0; index < size; index++ {
-		_a, _ := Nth(a, index)
-		_b, _ := Nth(b, index)
-		_c, _ := Nth(c, index)
-		_d, _ := Nth(d, index)
-		_e, _ := Nth(e, index)
-
-		result = append(result, Tuple5[A, B, C, D, E]{
-			A: _a,
-			B: _b,
-			C: _c,
-			D: _d,
-			E: _e,
-		})
+	for index := uint(0); index < size; index++ {
+		result[index].A = NthOrEmpty(a, index)
+		result[index].B = NthOrEmpty(b, index)
+		result[index].C = NthOrEmpty(c, index)
+		result[index].D = NthOrEmpty(d, index)
+		result[index].E = NthOrEmpty(e, index)
 	}
 
 	return result
 }
 
 // Zip6 creates a slice of grouped elements, the first of which contains the first elements
-// of the given arrays, the second of which contains the second elements of the given arrays, and so on.
-// When collections have different size, the Tuple attributes are filled with zero value.
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
 // Play: https://go.dev/play/p/jujaA6GaJTp
-func Zip6[A any, B any, C any, D any, E any, F any](a []A, b []B, c []C, d []D, e []E, f []F) []Tuple6[A, B, C, D, E, F] {
-	size := Max([]int{len(a), len(b), len(c), len(d), len(e), len(f)})
-
-	result := make([]Tuple6[A, B, C, D, E, F], 0, size)
-
-	for index := 0; index < size; index++ {
-		_a, _ := Nth(a, index)
-		_b, _ := Nth(b, index)
-		_c, _ := Nth(c, index)
-		_d, _ := Nth(d, index)
-		_e, _ := Nth(e, index)
-		_f, _ := Nth(f, index)
-
-		result = append(result, Tuple6[A, B, C, D, E, F]{
-			A: _a,
-			B: _b,
-			C: _c,
-			D: _d,
-			E: _e,
-			F: _f,
-		})
+func Zip6[A, B, C, D, E, F any](a []A, b []B, c []C, d []D, e []E, f []F) []Tuple6[A, B, C, D, E, F] {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d), len(e), len(f)}))
+
+	result := make([]Tuple6[A, B, C, D, E, F], size)
+
+	for index := uint(0); index < size; index++ {
+		result[index].A = NthOrEmpty(a, index)
+		result[index].B = NthOrEmpty(b, index)
+		result[index].C = NthOrEmpty(c, index)
+		result[index].D = NthOrEmpty(d, index)
+		result[index].E = NthOrEmpty(e, index)
+		result[index].F = NthOrEmpty(f, index)
 	}
 
 	return result
 }
 
 // Zip7 creates a slice of grouped elements, the first of which contains the first elements
-// of the given arrays, the second of which contains the second elements of the given arrays, and so on.
-// When collections have different size, the Tuple attributes are filled with zero value.
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
 // Play: https://go.dev/play/p/jujaA6GaJTp
-func Zip7[A any, B any, C any, D any, E any, F any, G any](a []A, b []B, c []C, d []D, e []E, f []F, g []G) []Tuple7[A, B, C, D, E, F, G] {
-	size := Max([]int{len(a), len(b), len(c), len(d), len(e), len(f), len(g)})
-
-	result := make([]Tuple7[A, B, C, D, E, F, G], 0, size)
-
-	for index := 0; index < size; index++ {
-		_a, _ := Nth(a, index)
-		_b, _ := Nth(b, index)
-		_c, _ := Nth(c, index)
-		_d, _ := Nth(d, index)
-		_e, _ := Nth(e, index)
-		_f, _ := Nth(f, index)
-		_g, _ := Nth(g, index)
-
-		result = append(result, Tuple7[A, B, C, D, E, F, G]{
-			A: _a,
-			B: _b,
-			C: _c,
-			D: _d,
-			E: _e,
-			F: _f,
-			G: _g,
-		})
+func Zip7[A, B, C, D, E, F, G any](a []A, b []B, c []C, d []D, e []E, f []F, g []G) []Tuple7[A, B, C, D, E, F, G] {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d), len(e), len(f), len(g)}))
+
+	result := make([]Tuple7[A, B, C, D, E, F, G], size)
+
+	for index := uint(0); index < size; index++ {
+		result[index].A = NthOrEmpty(a, index)
+		result[index].B = NthOrEmpty(b, index)
+		result[index].C = NthOrEmpty(c, index)
+		result[index].D = NthOrEmpty(d, index)
+		result[index].E = NthOrEmpty(e, index)
+		result[index].F = NthOrEmpty(f, index)
+		result[index].G = NthOrEmpty(g, index)
 	}
 
 	return result
 }
 
 // Zip8 creates a slice of grouped elements, the first of which contains the first elements
-// of the given arrays, the second of which contains the second elements of the given arrays, and so on.
-// When collections have different size, the Tuple attributes are filled with zero value.
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
 // Play: https://go.dev/play/p/jujaA6GaJTp
-func Zip8[A any, B any, C any, D any, E any, F any, G any, H any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H) []Tuple8[A, B, C, D, E, F, G, H] {
-	size := Max([]int{len(a), len(b), len(c), len(d), len(e), len(f), len(g), len(h)})
-
-	result := make([]Tuple8[A, B, C, D, E, F, G, H], 0, size)
-
-	for index := 0; index < size; index++ {
-		_a, _ := Nth(a, index)
-		_b, _ := Nth(b, index)
-		_c, _ := Nth(c, index)
-		_d, _ := Nth(d, index)
-		_e, _ := Nth(e, index)
-		_f, _ := Nth(f, index)
-		_g, _ := Nth(g, index)
-		_h, _ := Nth(h, index)
-
-		result = append(result, Tuple8[A, B, C, D, E, F, G, H]{
-			A: _a,
-			B: _b,
-			C: _c,
-			D: _d,
-			E: _e,
-			F: _f,
-			G: _g,
-			H: _h,
-		})
+func Zip8[A, B, C, D, E, F, G, H any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H) []Tuple8[A, B, C, D, E, F, G, H] {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d), len(e), len(f), len(g), len(h)}))
+
+	result := make([]Tuple8[A, B, C, D, E, F, G, H], size)
+
+	for index := uint(0); index < size; index++ {
+		result[index].A = NthOrEmpty(a, index)
+		result[index].B = NthOrEmpty(b, index)
+		result[index].C = NthOrEmpty(c, index)
+		result[index].D = NthOrEmpty(d, index)
+		result[index].E = NthOrEmpty(e, index)
+		result[index].F = NthOrEmpty(f, index)
+		result[index].G = NthOrEmpty(g, index)
+		result[index].H = NthOrEmpty(h, index)
 	}
 
 	return result
 }
 
 // Zip9 creates a slice of grouped elements, the first of which contains the first elements
-// of the given arrays, the second of which contains the second elements of the given arrays, and so on.
-// When collections have different size, the Tuple attributes are filled with zero value.
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
 // Play: https://go.dev/play/p/jujaA6GaJTp
-func Zip9[A any, B any, C any, D any, E any, F any, G any, H any, I any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I) []Tuple9[A, B, C, D, E, F, G, H, I] {
-	size := Max([]int{len(a), len(b), len(c), len(d), len(e), len(f), len(g), len(h), len(i)})
-
-	result := make([]Tuple9[A, B, C, D, E, F, G, H, I], 0, size)
-
-	for index := 0; index < size; index++ {
-		_a, _ := Nth(a, index)
-		_b, _ := Nth(b, index)
-		_c, _ := Nth(c, index)
-		_d, _ := Nth(d, index)
-		_e, _ := Nth(e, index)
-		_f, _ := Nth(f, index)
-		_g, _ := Nth(g, index)
-		_h, _ := Nth(h, index)
-		_i, _ := Nth(i, index)
-
-		result = append(result, Tuple9[A, B, C, D, E, F, G, H, I]{
-			A: _a,
-			B: _b,
-			C: _c,
-			D: _d,
-			E: _e,
-			F: _f,
-			G: _g,
-			H: _h,
-			I: _i,
-		})
+func Zip9[A, B, C, D, E, F, G, H, I any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I) []Tuple9[A, B, C, D, E, F, G, H, I] {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d), len(e), len(f), len(g), len(h), len(i)}))
+
+	result := make([]Tuple9[A, B, C, D, E, F, G, H, I], size)
+
+	for index := uint(0); index < size; index++ {
+		result[index].A = NthOrEmpty(a, index)
+		result[index].B = NthOrEmpty(b, index)
+		result[index].C = NthOrEmpty(c, index)
+		result[index].D = NthOrEmpty(d, index)
+		result[index].E = NthOrEmpty(e, index)
+		result[index].F = NthOrEmpty(f, index)
+		result[index].G = NthOrEmpty(g, index)
+		result[index].H = NthOrEmpty(h, index)
+		result[index].I = NthOrEmpty(i, index)
+	}
+
+	return result
+}
+
+// ZipBy2 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// Play: https://go.dev/play/p/wlHur6yO8rR
+func ZipBy2[A, B, Out any](a []A, b []B, iteratee func(a A, b B) Out) []Out {
+	size := uint(Max([]int{len(a), len(b)}))
+
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		result[index] = iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+		)
+	}
+
+	return result
+}
+
+// ZipBy3 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// Play: https://go.dev/play/p/j9maveOnSQX
+func ZipBy3[A, B, C, Out any](a []A, b []B, c []C, iteratee func(a A, b B, c C) Out) []Out {
+	size := uint(Max([]int{len(a), len(b), len(c)}))
+
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		result[index] = iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+			NthOrEmpty(c, index),
+		)
+	}
+
+	return result
+}
+
+// ZipBy4 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// Play: https://go.dev/play/p/Y1eF2Ke0Ayz
+func ZipBy4[A, B, C, D, Out any](a []A, b []B, c []C, d []D, iteratee func(a A, b B, c C, d D) Out) []Out {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d)}))
+
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		result[index] = iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+			NthOrEmpty(c, index),
+			NthOrEmpty(d, index),
+		)
+	}
+
+	return result
+}
+
+// ZipBy5 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// Play: https://go.dev/play/p/SLynyalh5Oa
+func ZipBy5[A, B, C, D, E, Out any](a []A, b []B, c []C, d []D, e []E, iteratee func(a A, b B, c C, d D, e E) Out) []Out {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d), len(e)}))
+
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		result[index] = iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+			NthOrEmpty(c, index),
+			NthOrEmpty(d, index),
+			NthOrEmpty(e, index),
+		)
+	}
+
+	return result
+}
+
+// ZipBy6 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// Play: https://go.dev/play/p/IK6KVgw9e-S
+func ZipBy6[A, B, C, D, E, F, Out any](a []A, b []B, c []C, d []D, e []E, f []F, iteratee func(a A, b B, c C, d D, e E, f F) Out) []Out {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d), len(e), len(f)}))
+
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		result[index] = iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+			NthOrEmpty(c, index),
+			NthOrEmpty(d, index),
+			NthOrEmpty(e, index),
+			NthOrEmpty(f, index),
+		)
+	}
+
+	return result
+}
+
+// ZipBy7 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// Play: https://go.dev/play/p/4uW6a2vXh8w
+func ZipBy7[A, B, C, D, E, F, G, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, iteratee func(a A, b B, c C, d D, e E, f F, g G) Out) []Out {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d), len(e), len(f), len(g)}))
+
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		result[index] = iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+			NthOrEmpty(c, index),
+			NthOrEmpty(d, index),
+			NthOrEmpty(e, index),
+			NthOrEmpty(f, index),
+			NthOrEmpty(g, index),
+		)
+	}
+
+	return result
+}
+
+// ZipBy8 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// Play: https://go.dev/play/p/tk8xW7XzY4v
+func ZipBy8[A, B, C, D, E, F, G, H, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, iteratee func(a A, b B, c C, d D, e E, f F, g G, h H) Out) []Out {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d), len(e), len(f), len(g), len(h)}))
+
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		result[index] = iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+			NthOrEmpty(c, index),
+			NthOrEmpty(d, index),
+			NthOrEmpty(e, index),
+			NthOrEmpty(f, index),
+			NthOrEmpty(g, index),
+			NthOrEmpty(h, index),
+		)
+	}
+
+	return result
+}
+
+// ZipBy9 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// Play: https://go.dev/play/p/VGqjDmQ9YqX
+func ZipBy9[A, B, C, D, E, F, G, H, I, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I, iteratee func(a A, b B, c C, d D, e E, f F, g G, h H, i I) Out) []Out {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d), len(e), len(f), len(g), len(h), len(i)}))
+
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		result[index] = iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+			NthOrEmpty(c, index),
+			NthOrEmpty(d, index),
+			NthOrEmpty(e, index),
+			NthOrEmpty(f, index),
+			NthOrEmpty(g, index),
+			NthOrEmpty(h, index),
+			NthOrEmpty(i, index),
+		)
 	}
 
 	return result
 }
 
-// Unzip2 accepts an array of grouped elements and creates an array regrouping the elements
+// ZipByErr2 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// It returns the first error returned by the iteratee.
+func ZipByErr2[A, B, Out any](a []A, b []B, iteratee func(a A, b B) (Out, error)) ([]Out, error) {
+	size := uint(Max([]int{len(a), len(b)}))
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		r, err := iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+		)
+		if err != nil {
+			return nil, err
+		}
+		result[index] = r
+	}
+
+	return result, nil
+}
+
+// ZipByErr3 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// It returns the first error returned by the iteratee.
+func ZipByErr3[A, B, C, Out any](a []A, b []B, c []C, iteratee func(a A, b B, c C) (Out, error)) ([]Out, error) {
+	size := uint(Max([]int{len(a), len(b), len(c)}))
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		r, err := iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+			NthOrEmpty(c, index),
+		)
+		if err != nil {
+			return nil, err
+		}
+		result[index] = r
+	}
+
+	return result, nil
+}
+
+// ZipByErr4 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// It returns the first error returned by the iteratee.
+func ZipByErr4[A, B, C, D, Out any](a []A, b []B, c []C, d []D, iteratee func(a A, b B, c C, d D) (Out, error)) ([]Out, error) {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d)}))
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		r, err := iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+			NthOrEmpty(c, index),
+			NthOrEmpty(d, index),
+		)
+		if err != nil {
+			return nil, err
+		}
+		result[index] = r
+	}
+
+	return result, nil
+}
+
+// ZipByErr5 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// It returns the first error returned by the iteratee.
+func ZipByErr5[A, B, C, D, E, Out any](a []A, b []B, c []C, d []D, e []E, iteratee func(a A, b B, c C, d D, e E) (Out, error)) ([]Out, error) {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d), len(e)}))
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		r, err := iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+			NthOrEmpty(c, index),
+			NthOrEmpty(d, index),
+			NthOrEmpty(e, index),
+		)
+		if err != nil {
+			return nil, err
+		}
+		result[index] = r
+	}
+
+	return result, nil
+}
+
+// ZipByErr6 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// It returns the first error returned by the iteratee.
+func ZipByErr6[A, B, C, D, E, F, Out any](a []A, b []B, c []C, d []D, e []E, f []F, iteratee func(a A, b B, c C, d D, e E, f F) (Out, error)) ([]Out, error) {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d), len(e), len(f)}))
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		r, err := iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+			NthOrEmpty(c, index),
+			NthOrEmpty(d, index),
+			NthOrEmpty(e, index),
+			NthOrEmpty(f, index),
+		)
+		if err != nil {
+			return nil, err
+		}
+		result[index] = r
+	}
+
+	return result, nil
+}
+
+// ZipByErr7 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// It returns the first error returned by the iteratee.
+func ZipByErr7[A, B, C, D, E, F, G, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, iteratee func(a A, b B, c C, d D, e E, f F, g G) (Out, error)) ([]Out, error) {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d), len(e), len(f), len(g)}))
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		r, err := iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+			NthOrEmpty(c, index),
+			NthOrEmpty(d, index),
+			NthOrEmpty(e, index),
+			NthOrEmpty(f, index),
+			NthOrEmpty(g, index),
+		)
+		if err != nil {
+			return nil, err
+		}
+		result[index] = r
+	}
+
+	return result, nil
+}
+
+// ZipByErr8 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// It returns the first error returned by the iteratee.
+func ZipByErr8[A, B, C, D, E, F, G, H, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, iteratee func(a A, b B, c C, d D, e E, f F, g G, h H) (Out, error)) ([]Out, error) {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d), len(e), len(f), len(g), len(h)}))
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		r, err := iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+			NthOrEmpty(c, index),
+			NthOrEmpty(d, index),
+			NthOrEmpty(e, index),
+			NthOrEmpty(f, index),
+			NthOrEmpty(g, index),
+			NthOrEmpty(h, index),
+		)
+		if err != nil {
+			return nil, err
+		}
+		result[index] = r
+	}
+
+	return result, nil
+}
+
+// ZipByErr9 creates a slice of transformed elements, the first of which contains the first elements
+// of the given slices, the second of which contains the second elements of the given slices, and so on.
+// When collections are different sizes, the Tuple attributes are filled with zero value.
+// It returns the first error returned by the iteratee.
+func ZipByErr9[A, B, C, D, E, F, G, H, I, Out any](a []A, b []B, c []C, d []D, e []E, f []F, g []G, h []H, i []I, iteratee func(a A, b B, c C, d D, e E, f F, g G, h H, i I) (Out, error)) ([]Out, error) {
+	size := uint(Max([]int{len(a), len(b), len(c), len(d), len(e), len(f), len(g), len(h), len(i)}))
+	result := make([]Out, size)
+
+	for index := uint(0); index < size; index++ {
+		r, err := iteratee(
+			NthOrEmpty(a, index),
+			NthOrEmpty(b, index),
+			NthOrEmpty(c, index),
+			NthOrEmpty(d, index),
+			NthOrEmpty(e, index),
+			NthOrEmpty(f, index),
+			NthOrEmpty(g, index),
+			NthOrEmpty(h, index),
+			NthOrEmpty(i, index),
+		)
+		if err != nil {
+			return nil, err
+		}
+		result[index] = r
+	}
+
+	return result, nil
+}
+
+// Unzip2 accepts a slice of grouped elements and creates a slice regrouping the elements
 // to their pre-zip configuration.
 // Play: https://go.dev/play/p/ciHugugvaAW
-func Unzip2[A any, B any](tuples []Tuple2[A, B]) ([]A, []B) {
+func Unzip2[A, B any](tuples []Tuple2[A, B]) ([]A, []B) {
 	size := len(tuples)
 	r1 := make([]A, 0, size)
 	r2 := make([]B, 0, size)
 
-	for _, tuple := range tuples {
-		r1 = append(r1, tuple.A)
-		r2 = append(r2, tuple.B)
+	for i := range tuples {
+		r1 = append(r1, tuples[i].A)
+		r2 = append(r2, tuples[i].B)
 	}
 
 	return r1, r2
 }
 
-// Unzip3 accepts an array of grouped elements and creates an array regrouping the elements
+// Unzip3 accepts a slice of grouped elements and creates a slice regrouping the elements
 // to their pre-zip configuration.
 // Play: https://go.dev/play/p/ciHugugvaAW
-func Unzip3[A any, B any, C any](tuples []Tuple3[A, B, C]) ([]A, []B, []C) {
+func Unzip3[A, B, C any](tuples []Tuple3[A, B, C]) ([]A, []B, []C) {
 	size := len(tuples)
 	r1 := make([]A, 0, size)
 	r2 := make([]B, 0, size)
 	r3 := make([]C, 0, size)
 
-	for _, tuple := range tuples {
-		r1 = append(r1, tuple.A)
-		r2 = append(r2, tuple.B)
-		r3 = append(r3, tuple.C)
+	for i := range tuples {
+		r1 = append(r1, tuples[i].A)
+		r2 = append(r2, tuples[i].B)
+		r3 = append(r3, tuples[i].C)
 	}
 
 	return r1, r2, r3
 }
 
-// Unzip4 accepts an array of grouped elements and creates an array regrouping the elements
+// Unzip4 accepts a slice of grouped elements and creates a slice regrouping the elements
 // to their pre-zip configuration.
 // Play: https://go.dev/play/p/ciHugugvaAW
-func Unzip4[A any, B any, C any, D any](tuples []Tuple4[A, B, C, D]) ([]A, []B, []C, []D) {
+func Unzip4[A, B, C, D any](tuples []Tuple4[A, B, C, D]) ([]A, []B, []C, []D) {
 	size := len(tuples)
 	r1 := make([]A, 0, size)
 	r2 := make([]B, 0, size)
 	r3 := make([]C, 0, size)
 	r4 := make([]D, 0, size)
 
-	for _, tuple := range tuples {
-		r1 = append(r1, tuple.A)
-		r2 = append(r2, tuple.B)
-		r3 = append(r3, tuple.C)
-		r4 = append(r4, tuple.D)
+	for i := range tuples {
+		r1 = append(r1, tuples[i].A)
+		r2 = append(r2, tuples[i].B)
+		r3 = append(r3, tuples[i].C)
+		r4 = append(r4, tuples[i].D)
 	}
 
 	return r1, r2, r3, r4
 }
 
-// Unzip5 accepts an array of grouped elements and creates an array regrouping the elements
+// Unzip5 accepts a slice of grouped elements and creates a slice regrouping the elements
 // to their pre-zip configuration.
 // Play: https://go.dev/play/p/ciHugugvaAW
-func Unzip5[A any, B any, C any, D any, E any](tuples []Tuple5[A, B, C, D, E]) ([]A, []B, []C, []D, []E) {
+func Unzip5[A, B, C, D, E any](tuples []Tuple5[A, B, C, D, E]) ([]A, []B, []C, []D, []E) {
 	size := len(tuples)
 	r1 := make([]A, 0, size)
 	r2 := make([]B, 0, size)
@@ -393,21 +709,21 @@ func Unzip5[A any, B any, C any, D any, E any](tuples []Tuple5[A, B, C, D, E]) (
 	r4 := make([]D, 0, size)
 	r5 := make([]E, 0, size)
 
-	for _, tuple := range tuples {
-		r1 = append(r1, tuple.A)
-		r2 = append(r2, tuple.B)
-		r3 = append(r3, tuple.C)
-		r4 = append(r4, tuple.D)
-		r5 = append(r5, tuple.E)
+	for i := range tuples {
+		r1 = append(r1, tuples[i].A)
+		r2 = append(r2, tuples[i].B)
+		r3 = append(r3, tuples[i].C)
+		r4 = append(r4, tuples[i].D)
+		r5 = append(r5, tuples[i].E)
 	}
 
 	return r1, r2, r3, r4, r5
 }
 
-// Unzip6 accepts an array of grouped elements and creates an array regrouping the elements
+// Unzip6 accepts a slice of grouped elements and creates a slice regrouping the elements
 // to their pre-zip configuration.
 // Play: https://go.dev/play/p/ciHugugvaAW
-func Unzip6[A any, B any, C any, D any, E any, F any](tuples []Tuple6[A, B, C, D, E, F]) ([]A, []B, []C, []D, []E, []F) {
+func Unzip6[A, B, C, D, E, F any](tuples []Tuple6[A, B, C, D, E, F]) ([]A, []B, []C, []D, []E, []F) {
 	size := len(tuples)
 	r1 := make([]A, 0, size)
 	r2 := make([]B, 0, size)
@@ -416,22 +732,22 @@ func Unzip6[A any, B any, C any, D any, E any, F any](tuples []Tuple6[A, B, C, D
 	r5 := make([]E, 0, size)
 	r6 := make([]F, 0, size)
 
-	for _, tuple := range tuples {
-		r1 = append(r1, tuple.A)
-		r2 = append(r2, tuple.B)
-		r3 = append(r3, tuple.C)
-		r4 = append(r4, tuple.D)
-		r5 = append(r5, tuple.E)
-		r6 = append(r6, tuple.F)
+	for i := range tuples {
+		r1 = append(r1, tuples[i].A)
+		r2 = append(r2, tuples[i].B)
+		r3 = append(r3, tuples[i].C)
+		r4 = append(r4, tuples[i].D)
+		r5 = append(r5, tuples[i].E)
+		r6 = append(r6, tuples[i].F)
 	}
 
 	return r1, r2, r3, r4, r5, r6
 }
 
-// Unzip7 accepts an array of grouped elements and creates an array regrouping the elements
+// Unzip7 accepts a slice of grouped elements and creates a slice regrouping the elements
 // to their pre-zip configuration.
 // Play: https://go.dev/play/p/ciHugugvaAW
-func Unzip7[A any, B any, C any, D any, E any, F any, G any](tuples []Tuple7[A, B, C, D, E, F, G]) ([]A, []B, []C, []D, []E, []F, []G) {
+func Unzip7[A, B, C, D, E, F, G any](tuples []Tuple7[A, B, C, D, E, F, G]) ([]A, []B, []C, []D, []E, []F, []G) {
 	size := len(tuples)
 	r1 := make([]A, 0, size)
 	r2 := make([]B, 0, size)
@@ -441,23 +757,23 @@ func Unzip7[A any, B any, C any, D any, E any, F any, G any](tuples []Tuple7[A,
 	r6 := make([]F, 0, size)
 	r7 := make([]G, 0, size)
 
-	for _, tuple := range tuples {
-		r1 = append(r1, tuple.A)
-		r2 = append(r2, tuple.B)
-		r3 = append(r3, tuple.C)
-		r4 = append(r4, tuple.D)
-		r5 = append(r5, tuple.E)
-		r6 = append(r6, tuple.F)
-		r7 = append(r7, tuple.G)
+	for i := range tuples {
+		r1 = append(r1, tuples[i].A)
+		r2 = append(r2, tuples[i].B)
+		r3 = append(r3, tuples[i].C)
+		r4 = append(r4, tuples[i].D)
+		r5 = append(r5, tuples[i].E)
+		r6 = append(r6, tuples[i].F)
+		r7 = append(r7, tuples[i].G)
 	}
 
 	return r1, r2, r3, r4, r5, r6, r7
 }
 
-// Unzip8 accepts an array of grouped elements and creates an array regrouping the elements
+// Unzip8 accepts a slice of grouped elements and creates a slice regrouping the elements
 // to their pre-zip configuration.
 // Play: https://go.dev/play/p/ciHugugvaAW
-func Unzip8[A any, B any, C any, D any, E any, F any, G any, H any](tuples []Tuple8[A, B, C, D, E, F, G, H]) ([]A, []B, []C, []D, []E, []F, []G, []H) {
+func Unzip8[A, B, C, D, E, F, G, H any](tuples []Tuple8[A, B, C, D, E, F, G, H]) ([]A, []B, []C, []D, []E, []F, []G, []H) {
 	size := len(tuples)
 	r1 := make([]A, 0, size)
 	r2 := make([]B, 0, size)
@@ -468,24 +784,24 @@ func Unzip8[A any, B any, C any, D any, E any, F any, G any, H any](tuples []Tup
 	r7 := make([]G, 0, size)
 	r8 := make([]H, 0, size)
 
-	for _, tuple := range tuples {
-		r1 = append(r1, tuple.A)
-		r2 = append(r2, tuple.B)
-		r3 = append(r3, tuple.C)
-		r4 = append(r4, tuple.D)
-		r5 = append(r5, tuple.E)
-		r6 = append(r6, tuple.F)
-		r7 = append(r7, tuple.G)
-		r8 = append(r8, tuple.H)
+	for i := range tuples {
+		r1 = append(r1, tuples[i].A)
+		r2 = append(r2, tuples[i].B)
+		r3 = append(r3, tuples[i].C)
+		r4 = append(r4, tuples[i].D)
+		r5 = append(r5, tuples[i].E)
+		r6 = append(r6, tuples[i].F)
+		r7 = append(r7, tuples[i].G)
+		r8 = append(r8, tuples[i].H)
 	}
 
 	return r1, r2, r3, r4, r5, r6, r7, r8
 }
 
-// Unzip9 accepts an array of grouped elements and creates an array regrouping the elements
+// Unzip9 accepts a slice of grouped elements and creates a slice regrouping the elements
 // to their pre-zip configuration.
 // Play: https://go.dev/play/p/ciHugugvaAW
-func Unzip9[A any, B any, C any, D any, E any, F any, G any, H any, I any](tuples []Tuple9[A, B, C, D, E, F, G, H, I]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I) {
+func Unzip9[A, B, C, D, E, F, G, H, I any](tuples []Tuple9[A, B, C, D, E, F, G, H, I]) ([]A, []B, []C, []D, []E, []F, []G, []H, []I) {
 	size := len(tuples)
 	r1 := make([]A, 0, size)
 	r2 := make([]B, 0, size)
@@ -497,17 +813,985 @@ func Unzip9[A any, B any, C any, D any, E any, F any, G any, H any, I any](tuple
 	r8 := make([]H, 0, size)
 	r9 := make([]I, 0, size)
 
-	for _, tuple := range tuples {
-		r1 = append(r1, tuple.A)
-		r2 = append(r2, tuple.B)
-		r3 = append(r3, tuple.C)
-		r4 = append(r4, tuple.D)
-		r5 = append(r5, tuple.E)
-		r6 = append(r6, tuple.F)
-		r7 = append(r7, tuple.G)
-		r8 = append(r8, tuple.H)
-		r9 = append(r9, tuple.I)
+	for i := range tuples {
+		r1 = append(r1, tuples[i].A)
+		r2 = append(r2, tuples[i].B)
+		r3 = append(r3, tuples[i].C)
+		r4 = append(r4, tuples[i].D)
+		r5 = append(r5, tuples[i].E)
+		r6 = append(r6, tuples[i].F)
+		r7 = append(r7, tuples[i].G)
+		r8 = append(r8, tuples[i].H)
+		r9 = append(r9, tuples[i].I)
 	}
 
 	return r1, r2, r3, r4, r5, r6, r7, r8, r9
 }
+
+// UnzipBy2 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// Play: https://go.dev/play/p/tN8yqaRZz0r
+func UnzipBy2[In, A, B any](items []In, iteratee func(In) (a A, b B)) ([]A, []B) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+
+	for i := range items {
+		a, b := iteratee(items[i])
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+	}
+
+	return r1, r2
+}
+
+// UnzipBy3 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// Play: https://go.dev/play/p/36ITO2DlQq1
+func UnzipBy3[In, A, B, C any](items []In, iteratee func(In) (a A, b B, c C)) ([]A, []B, []C) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+	r3 := make([]C, 0, size)
+
+	for i := range items {
+		a, b, c := iteratee(items[i])
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+		r3 = append(r3, c)
+	}
+
+	return r1, r2, r3
+}
+
+// UnzipBy4 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// Play: https://go.dev/play/p/zJ6qY1dD1rL
+func UnzipBy4[In, A, B, C, D any](items []In, iteratee func(In) (a A, b B, c C, d D)) ([]A, []B, []C, []D) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+	r3 := make([]C, 0, size)
+	r4 := make([]D, 0, size)
+
+	for i := range items {
+		a, b, c, d := iteratee(items[i])
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+		r3 = append(r3, c)
+		r4 = append(r4, d)
+	}
+
+	return r1, r2, r3, r4
+}
+
+// UnzipBy5 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// Play: https://go.dev/play/p/3f7jKkV9xZt
+func UnzipBy5[In, A, B, C, D, E any](items []In, iteratee func(In) (a A, b B, c C, d D, e E)) ([]A, []B, []C, []D, []E) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+	r3 := make([]C, 0, size)
+	r4 := make([]D, 0, size)
+	r5 := make([]E, 0, size)
+
+	for i := range items {
+		a, b, c, d, e := iteratee(items[i])
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+		r3 = append(r3, c)
+		r4 = append(r4, d)
+		r5 = append(r5, e)
+	}
+
+	return r1, r2, r3, r4, r5
+}
+
+// UnzipBy6 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// Play: https://go.dev/play/p/8Y1b7tKu2pL
+func UnzipBy6[In, A, B, C, D, E, F any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F)) ([]A, []B, []C, []D, []E, []F) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+	r3 := make([]C, 0, size)
+	r4 := make([]D, 0, size)
+	r5 := make([]E, 0, size)
+	r6 := make([]F, 0, size)
+
+	for i := range items {
+		a, b, c, d, e, f := iteratee(items[i])
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+		r3 = append(r3, c)
+		r4 = append(r4, d)
+		r5 = append(r5, e)
+		r6 = append(r6, f)
+	}
+
+	return r1, r2, r3, r4, r5, r6
+}
+
+// UnzipBy7 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// Play: https://go.dev/play/p/7j1kLmVn3pM
+func UnzipBy7[In, A, B, C, D, E, F, G any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G)) ([]A, []B, []C, []D, []E, []F, []G) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+	r3 := make([]C, 0, size)
+	r4 := make([]D, 0, size)
+	r5 := make([]E, 0, size)
+	r6 := make([]F, 0, size)
+	r7 := make([]G, 0, size)
+
+	for i := range items {
+		a, b, c, d, e, f, g := iteratee(items[i])
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+		r3 = append(r3, c)
+		r4 = append(r4, d)
+		r5 = append(r5, e)
+		r6 = append(r6, f)
+		r7 = append(r7, g)
+	}
+
+	return r1, r2, r3, r4, r5, r6, r7
+}
+
+// UnzipBy8 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// Play: https://go.dev/play/p/1n2k3L4m5N6
+func UnzipBy8[In, A, B, C, D, E, F, G, H any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G, h H)) ([]A, []B, []C, []D, []E, []F, []G, []H) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+	r3 := make([]C, 0, size)
+	r4 := make([]D, 0, size)
+	r5 := make([]E, 0, size)
+	r6 := make([]F, 0, size)
+	r7 := make([]G, 0, size)
+	r8 := make([]H, 0, size)
+
+	for i := range items {
+		a, b, c, d, e, f, g, h := iteratee(items[i])
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+		r3 = append(r3, c)
+		r4 = append(r4, d)
+		r5 = append(r5, e)
+		r6 = append(r6, f)
+		r7 = append(r7, g)
+		r8 = append(r8, h)
+	}
+
+	return r1, r2, r3, r4, r5, r6, r7, r8
+}
+
+// UnzipBy9 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// Play: https://go.dev/play/p/7o8p9q0r1s2
+func UnzipBy9[In, A, B, C, D, E, F, G, H, I any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G, h H, i I)) ([]A, []B, []C, []D, []E, []F, []G, []H, []I) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+	r3 := make([]C, 0, size)
+	r4 := make([]D, 0, size)
+	r5 := make([]E, 0, size)
+	r6 := make([]F, 0, size)
+	r7 := make([]G, 0, size)
+	r8 := make([]H, 0, size)
+	r9 := make([]I, 0, size)
+
+	for i := range items {
+		a, b, c, d, e, f, g, h, i := iteratee(items[i])
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+		r3 = append(r3, c)
+		r4 = append(r4, d)
+		r5 = append(r5, e)
+		r6 = append(r6, f)
+		r7 = append(r7, g)
+		r8 = append(r8, h)
+		r9 = append(r9, i)
+	}
+
+	return r1, r2, r3, r4, r5, r6, r7, r8, r9
+}
+
+// UnzipByErr2 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// It returns the first error returned by the iteratee.
+func UnzipByErr2[In, A, B any](items []In, iteratee func(In) (a A, b B, err error)) ([]A, []B, error) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+
+	for i := range items {
+		a, b, err := iteratee(items[i])
+		if err != nil {
+			return nil, nil, err
+		}
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+	}
+
+	return r1, r2, nil
+}
+
+// UnzipByErr3 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// It returns the first error returned by the iteratee.
+func UnzipByErr3[In, A, B, C any](items []In, iteratee func(In) (a A, b B, c C, err error)) ([]A, []B, []C, error) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+	r3 := make([]C, 0, size)
+
+	for i := range items {
+		a, b, c, err := iteratee(items[i])
+		if err != nil {
+			return nil, nil, nil, err
+		}
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+		r3 = append(r3, c)
+	}
+
+	return r1, r2, r3, nil
+}
+
+// UnzipByErr4 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// It returns the first error returned by the iteratee.
+func UnzipByErr4[In, A, B, C, D any](items []In, iteratee func(In) (a A, b B, c C, d D, err error)) ([]A, []B, []C, []D, error) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+	r3 := make([]C, 0, size)
+	r4 := make([]D, 0, size)
+
+	for i := range items {
+		a, b, c, d, err := iteratee(items[i])
+		if err != nil {
+			return nil, nil, nil, nil, err
+		}
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+		r3 = append(r3, c)
+		r4 = append(r4, d)
+	}
+
+	return r1, r2, r3, r4, nil
+}
+
+// UnzipByErr5 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// It returns the first error returned by the iteratee.
+func UnzipByErr5[In, A, B, C, D, E any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, err error)) ([]A, []B, []C, []D, []E, error) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+	r3 := make([]C, 0, size)
+	r4 := make([]D, 0, size)
+	r5 := make([]E, 0, size)
+
+	for i := range items {
+		a, b, c, d, e, err := iteratee(items[i])
+		if err != nil {
+			return nil, nil, nil, nil, nil, err
+		}
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+		r3 = append(r3, c)
+		r4 = append(r4, d)
+		r5 = append(r5, e)
+	}
+
+	return r1, r2, r3, r4, r5, nil
+}
+
+// UnzipByErr6 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// It returns the first error returned by the iteratee.
+func UnzipByErr6[In, A, B, C, D, E, F any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, err error)) ([]A, []B, []C, []D, []E, []F, error) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+	r3 := make([]C, 0, size)
+	r4 := make([]D, 0, size)
+	r5 := make([]E, 0, size)
+	r6 := make([]F, 0, size)
+
+	for i := range items {
+		a, b, c, d, e, f, err := iteratee(items[i])
+		if err != nil {
+			return nil, nil, nil, nil, nil, nil, err
+		}
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+		r3 = append(r3, c)
+		r4 = append(r4, d)
+		r5 = append(r5, e)
+		r6 = append(r6, f)
+	}
+
+	return r1, r2, r3, r4, r5, r6, nil
+}
+
+// UnzipByErr7 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// It returns the first error returned by the iteratee.
+func UnzipByErr7[In, A, B, C, D, E, F, G any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G, err error)) ([]A, []B, []C, []D, []E, []F, []G, error) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+	r3 := make([]C, 0, size)
+	r4 := make([]D, 0, size)
+	r5 := make([]E, 0, size)
+	r6 := make([]F, 0, size)
+	r7 := make([]G, 0, size)
+
+	for i := range items {
+		a, b, c, d, e, f, g, err := iteratee(items[i])
+		if err != nil {
+			return nil, nil, nil, nil, nil, nil, nil, err
+		}
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+		r3 = append(r3, c)
+		r4 = append(r4, d)
+		r5 = append(r5, e)
+		r6 = append(r6, f)
+		r7 = append(r7, g)
+	}
+
+	return r1, r2, r3, r4, r5, r6, r7, nil
+}
+
+// UnzipByErr8 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// It returns the first error returned by the iteratee.
+func UnzipByErr8[In, A, B, C, D, E, F, G, H any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G, h H, err error)) ([]A, []B, []C, []D, []E, []F, []G, []H, error) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+	r3 := make([]C, 0, size)
+	r4 := make([]D, 0, size)
+	r5 := make([]E, 0, size)
+	r6 := make([]F, 0, size)
+	r7 := make([]G, 0, size)
+	r8 := make([]H, 0, size)
+
+	for i := range items {
+		a, b, c, d, e, f, g, h, err := iteratee(items[i])
+		if err != nil {
+			return nil, nil, nil, nil, nil, nil, nil, nil, err
+		}
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+		r3 = append(r3, c)
+		r4 = append(r4, d)
+		r5 = append(r5, e)
+		r6 = append(r6, f)
+		r7 = append(r7, g)
+		r8 = append(r8, h)
+	}
+
+	return r1, r2, r3, r4, r5, r6, r7, r8, nil
+}
+
+// UnzipByErr9 iterates over a collection and creates a slice regrouping the elements
+// to their pre-zip configuration.
+// It returns the first error returned by the iteratee.
+func UnzipByErr9[In, A, B, C, D, E, F, G, H, I any](items []In, iteratee func(In) (a A, b B, c C, d D, e E, f F, g G, h H, i I, err error)) ([]A, []B, []C, []D, []E, []F, []G, []H, []I, error) {
+	size := len(items)
+	r1 := make([]A, 0, size)
+	r2 := make([]B, 0, size)
+	r3 := make([]C, 0, size)
+	r4 := make([]D, 0, size)
+	r5 := make([]E, 0, size)
+	r6 := make([]F, 0, size)
+	r7 := make([]G, 0, size)
+	r8 := make([]H, 0, size)
+	r9 := make([]I, 0, size)
+
+	for i := range items {
+		a, b, c, d, e, f, g, h, i, err := iteratee(items[i])
+		if err != nil {
+			return nil, nil, nil, nil, nil, nil, nil, nil, nil, err
+		}
+		r1 = append(r1, a)
+		r2 = append(r2, b)
+		r3 = append(r3, c)
+		r4 = append(r4, d)
+		r5 = append(r5, e)
+		r6 = append(r6, f)
+		r7 = append(r7, g)
+		r8 = append(r8, h)
+		r9 = append(r9, i)
+	}
+
+	return r1, r2, r3, r4, r5, r6, r7, r8, r9, nil
+}
+
+// CrossJoin2 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/3VFppyL9FDU
+func CrossJoin2[A, B any](listA []A, listB []B) []Tuple2[A, B] {
+	return CrossJoinBy2(listA, listB, T2[A, B])
+}
+
+// CrossJoin3 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/2WGeHyJj4fK
+func CrossJoin3[A, B, C any](listA []A, listB []B, listC []C) []Tuple3[A, B, C] {
+	return CrossJoinBy3(listA, listB, listC, T3[A, B, C])
+}
+
+// CrossJoin4 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/6XhKjLmMnNp
+func CrossJoin4[A, B, C, D any](listA []A, listB []B, listC []C, listD []D) []Tuple4[A, B, C, D] {
+	return CrossJoinBy4(listA, listB, listC, listD, T4[A, B, C, D])
+}
+
+// CrossJoin5 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/7oPqRsTuVwX
+func CrossJoin5[A, B, C, D, E any](listA []A, listB []B, listC []C, listD []D, listE []E) []Tuple5[A, B, C, D, E] {
+	return CrossJoinBy5(listA, listB, listC, listD, listE, T5[A, B, C, D, E])
+}
+
+// CrossJoin6 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/8yZ1aB2cD3e
+func CrossJoin6[A, B, C, D, E, F any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F) []Tuple6[A, B, C, D, E, F] {
+	return CrossJoinBy6(listA, listB, listC, listD, listE, listF, T6[A, B, C, D, E, F])
+}
+
+// CrossJoin7 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/9f4g5h6i7j8
+func CrossJoin7[A, B, C, D, E, F, G any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G) []Tuple7[A, B, C, D, E, F, G] {
+	return CrossJoinBy7(listA, listB, listC, listD, listE, listF, listG, T7[A, B, C, D, E, F, G])
+}
+
+// CrossJoin8 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/0k1l2m3n4o5
+func CrossJoin8[A, B, C, D, E, F, G, H any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, listH []H) []Tuple8[A, B, C, D, E, F, G, H] {
+	return CrossJoinBy8(listA, listB, listC, listD, listE, listF, listG, listH, T8[A, B, C, D, E, F, G, H])
+}
+
+// CrossJoin9 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/6p7q8r9s0t1
+func CrossJoin9[A, B, C, D, E, F, G, H, I any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, listH []H, listI []I) []Tuple9[A, B, C, D, E, F, G, H, I] {
+	return CrossJoinBy9(listA, listB, listC, listD, listE, listF, listG, listH, listI, T9[A, B, C, D, E, F, G, H, I])
+}
+
+// CrossJoinBy2 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/8Y7btpvuA-C
+func CrossJoinBy2[A, B, Out any](listA []A, listB []B, transform func(a A, b B) Out) []Out {
+	size := len(listA) * len(listB)
+	if size == 0 {
+		return []Out{}
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			result = append(result, transform(a, b))
+		}
+	}
+
+	return result
+}
+
+// CrossJoinBy3 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/3z4y5x6w7v8
+func CrossJoinBy3[A, B, C, Out any](listA []A, listB []B, listC []C, transform func(a A, b B, c C) Out) []Out {
+	size := len(listA) * len(listB) * len(listC)
+	if size == 0 {
+		return []Out{}
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			for _, c := range listC {
+				result = append(result, transform(a, b, c))
+			}
+		}
+	}
+
+	return result
+}
+
+// CrossJoinBy4 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/8b9c0d1e2f3
+func CrossJoinBy4[A, B, C, D, Out any](listA []A, listB []B, listC []C, listD []D, transform func(a A, b B, c C, d D) Out) []Out {
+	size := len(listA) * len(listB) * len(listC) * len(listD)
+	if size == 0 {
+		return []Out{}
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			for _, c := range listC {
+				for _, d := range listD {
+					result = append(result, transform(a, b, c, d))
+				}
+			}
+		}
+	}
+
+	return result
+}
+
+// CrossJoinBy5 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/4g5h6i7j8k9
+func CrossJoinBy5[A, B, C, D, E, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, transform func(a A, b B, c C, d D, e E) Out) []Out {
+	size := len(listA) * len(listB) * len(listC) * len(listD) * len(listE)
+	if size == 0 {
+		return []Out{}
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			for _, c := range listC {
+				for _, d := range listD {
+					for _, e := range listE {
+						result = append(result, transform(a, b, c, d, e))
+					}
+				}
+			}
+		}
+	}
+
+	return result
+}
+
+// CrossJoinBy6 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/1l2m3n4o5p6
+func CrossJoinBy6[A, B, C, D, E, F, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, transform func(a A, b B, c C, d D, e E, f F) Out) []Out {
+	size := len(listA) * len(listB) * len(listC) * len(listD) * len(listE) * len(listF)
+	if size == 0 {
+		return []Out{}
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			for _, c := range listC {
+				for _, d := range listD {
+					for _, e := range listE {
+						for _, f := range listF {
+							result = append(result, transform(a, b, c, d, e, f))
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return result
+}
+
+// CrossJoinBy7 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/7q8r9s0t1u2
+func CrossJoinBy7[A, B, C, D, E, F, G, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, transform func(a A, b B, c C, d D, e E, f F, g G) Out) []Out {
+	size := len(listA) * len(listB) * len(listC) * len(listD) * len(listE) * len(listF) * len(listG)
+	if size == 0 {
+		return []Out{}
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			for _, c := range listC {
+				for _, d := range listD {
+					for _, e := range listE {
+						for _, f := range listF {
+							for _, g := range listG {
+								result = append(result, transform(a, b, c, d, e, f, g))
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return result
+}
+
+// CrossJoinBy8 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/3v4w5x6y7z8
+func CrossJoinBy8[A, B, C, D, E, F, G, H, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, listH []H, transform func(a A, b B, c C, d D, e E, f F, g G, h H) Out) []Out {
+	size := len(listA) * len(listB) * len(listC) * len(listD) * len(listE) * len(listF) * len(listG) * len(listH)
+	if size == 0 {
+		return []Out{}
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			for _, c := range listC {
+				for _, d := range listD {
+					for _, e := range listE {
+						for _, f := range listF {
+							for _, g := range listG {
+								for _, h := range listH {
+									result = append(result, transform(a, b, c, d, e, f, g, h))
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return result
+}
+
+// CrossJoinBy9 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// Play: https://go.dev/play/p/9a0b1c2d3e4
+func CrossJoinBy9[A, B, C, D, E, F, G, H, I, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, listH []H, listI []I, transform func(a A, b B, c C, d D, e E, f F, g G, h H, i I) Out) []Out {
+	size := len(listA) * len(listB) * len(listC) * len(listD) * len(listE) * len(listF) * len(listG) * len(listH) * len(listI)
+	if size == 0 {
+		return []Out{}
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			for _, c := range listC {
+				for _, d := range listD {
+					for _, e := range listE {
+						for _, f := range listF {
+							for _, g := range listG {
+								for _, h := range listH {
+									for _, i := range listI {
+										result = append(result, transform(a, b, c, d, e, f, g, h, i))
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return result
+}
+
+// CrossJoinByErr2 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// It returns the first error returned by the transform function.
+func CrossJoinByErr2[A, B, Out any](listA []A, listB []B, transform func(a A, b B) (Out, error)) ([]Out, error) {
+	size := len(listA) * len(listB)
+	if size == 0 {
+		return []Out{}, nil
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			r, err := transform(a, b)
+			if err != nil {
+				return nil, err
+			}
+			result = append(result, r)
+		}
+	}
+
+	return result, nil
+}
+
+// CrossJoinByErr3 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// It returns the first error returned by the transform function.
+func CrossJoinByErr3[A, B, C, Out any](listA []A, listB []B, listC []C, transform func(a A, b B, c C) (Out, error)) ([]Out, error) {
+	size := len(listA) * len(listB) * len(listC)
+	if size == 0 {
+		return []Out{}, nil
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			for _, c := range listC {
+				r, err := transform(a, b, c)
+				if err != nil {
+					return nil, err
+				}
+				result = append(result, r)
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// CrossJoinByErr4 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// It returns the first error returned by the transform function.
+func CrossJoinByErr4[A, B, C, D, Out any](listA []A, listB []B, listC []C, listD []D, transform func(a A, b B, c C, d D) (Out, error)) ([]Out, error) {
+	size := len(listA) * len(listB) * len(listC) * len(listD)
+	if size == 0 {
+		return []Out{}, nil
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			for _, c := range listC {
+				for _, d := range listD {
+					r, err := transform(a, b, c, d)
+					if err != nil {
+						return nil, err
+					}
+					result = append(result, r)
+				}
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// CrossJoinByErr5 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// It returns the first error returned by the transform function.
+func CrossJoinByErr5[A, B, C, D, E, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, transform func(a A, b B, c C, d D, e E) (Out, error)) ([]Out, error) {
+	size := len(listA) * len(listB) * len(listC) * len(listD) * len(listE)
+	if size == 0 {
+		return []Out{}, nil
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			for _, c := range listC {
+				for _, d := range listD {
+					for _, e := range listE {
+						r, err := transform(a, b, c, d, e)
+						if err != nil {
+							return nil, err
+						}
+						result = append(result, r)
+					}
+				}
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// CrossJoinByErr6 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// It returns the first error returned by the transform function.
+func CrossJoinByErr6[A, B, C, D, E, F, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, transform func(a A, b B, c C, d D, e E, f F) (Out, error)) ([]Out, error) {
+	size := len(listA) * len(listB) * len(listC) * len(listD) * len(listE) * len(listF)
+	if size == 0 {
+		return []Out{}, nil
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			for _, c := range listC {
+				for _, d := range listD {
+					for _, e := range listE {
+						for _, f := range listF {
+							r, err := transform(a, b, c, d, e, f)
+							if err != nil {
+								return nil, err
+							}
+							result = append(result, r)
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// CrossJoinByErr7 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// It returns the first error returned by the transform function.
+func CrossJoinByErr7[A, B, C, D, E, F, G, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, transform func(a A, b B, c C, d D, e E, f F, g G) (Out, error)) ([]Out, error) {
+	size := len(listA) * len(listB) * len(listC) * len(listD) * len(listE) * len(listF) * len(listG)
+	if size == 0 {
+		return []Out{}, nil
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			for _, c := range listC {
+				for _, d := range listD {
+					for _, e := range listE {
+						for _, f := range listF {
+							for _, g := range listG {
+								r, err := transform(a, b, c, d, e, f, g)
+								if err != nil {
+									return nil, err
+								}
+								result = append(result, r)
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// CrossJoinByErr8 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// It returns the first error returned by the transform function.
+func CrossJoinByErr8[A, B, C, D, E, F, G, H, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, listH []H, transform func(a A, b B, c C, d D, e E, f F, g G, h H) (Out, error)) ([]Out, error) {
+	size := len(listA) * len(listB) * len(listC) * len(listD) * len(listE) * len(listF) * len(listG) * len(listH)
+	if size == 0 {
+		return []Out{}, nil
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			for _, c := range listC {
+				for _, d := range listD {
+					for _, e := range listE {
+						for _, f := range listF {
+							for _, g := range listG {
+								for _, h := range listH {
+									r, err := transform(a, b, c, d, e, f, g, h)
+									if err != nil {
+										return nil, err
+									}
+									result = append(result, r)
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return result, nil
+}
+
+// CrossJoinByErr9 combines every item from one list with every item from others.
+// It is the cartesian product of lists received as arguments. The transform function
+// is used to create the output values.
+// Returns an empty list if a list is empty.
+// It returns the first error returned by the transform function.
+func CrossJoinByErr9[A, B, C, D, E, F, G, H, I, Out any](listA []A, listB []B, listC []C, listD []D, listE []E, listF []F, listG []G, listH []H, listI []I, transform func(a A, b B, c C, d D, e E, f F, g G, h H, i I) (Out, error)) ([]Out, error) {
+	size := len(listA) * len(listB) * len(listC) * len(listD) * len(listE) * len(listF) * len(listG) * len(listH) * len(listI)
+	if size == 0 {
+		return []Out{}, nil
+	}
+
+	result := make([]Out, 0, size)
+
+	for _, a := range listA {
+		for _, b := range listB {
+			for _, c := range listC {
+				for _, d := range listD {
+					for _, e := range listE {
+						for _, f := range listF {
+							for _, g := range listG {
+								for _, h := range listH {
+									for _, i := range listI {
+										r, err := transform(a, b, c, d, e, f, g, h, i)
+										if err != nil {
+											return nil, err
+										}
+										result = append(result, r)
+									}
+								}
+							}
+						}
+					}
+				}
+			}
+		}
+	}
+
+	return result, nil
+}
diff --git a/vendor/github.com/samber/lo/type_manipulation.go b/vendor/github.com/samber/lo/type_manipulation.go
index fe99ee1f040..c2f93d7351f 100644
--- a/vendor/github.com/samber/lo/type_manipulation.go
+++ b/vendor/github.com/samber/lo/type_manipulation.go
@@ -1,11 +1,55 @@
 package lo
 
+import "reflect"
+
+// IsNil checks if a value is nil or if it's a reference type with a nil underlying value.
+// Play: https://go.dev/play/p/P2sD0PMXw4F
+func IsNil(x any) bool {
+	if x == nil {
+		return true
+	}
+	v := reflect.ValueOf(x)
+	switch v.Kind() { //nolint:exhaustive
+	case reflect.Chan, reflect.Func, reflect.Map, reflect.Pointer, reflect.UnsafePointer, reflect.Interface, reflect.Slice:
+		return v.IsNil()
+	default:
+		return false
+	}
+}
+
+// IsNotNil checks if a value is not nil or if it's not a reference type with a nil underlying value.
+// Play: https://go.dev/play/p/P2sD0PMXw4F
+func IsNotNil(x any) bool {
+	return !IsNil(x)
+}
+
 // ToPtr returns a pointer copy of value.
+// Play: https://go.dev/play/p/P2sD0PMXw4F
 func ToPtr[T any](x T) *T {
 	return &x
 }
 
+// Nil returns a nil pointer of type.
+// Play: https://go.dev/play/p/P2sD0PMXw4F
+func Nil[T any]() *T {
+	return nil
+}
+
+// EmptyableToPtr returns a pointer copy of value if it's nonzero.
+// Otherwise, returns nil pointer.
+// Play: https://go.dev/play/p/P2sD0PMXw4F
+func EmptyableToPtr[T any](x T) *T {
+	// 🤮
+	isZero := reflect.ValueOf(&x).Elem().IsZero()
+	if isZero {
+		return nil
+	}
+
+	return &x
+}
+
 // FromPtr returns the pointer value or empty.
+// Play: https://go.dev/play/p/mhD9CwO3X0m
 func FromPtr[T any](x *T) T {
 	if x == nil {
 		return Empty[T]()
@@ -15,6 +59,7 @@ func FromPtr[T any](x *T) T {
 }
 
 // FromPtrOr returns the pointer value or the fallback value.
+// Play: https://go.dev/play/p/mhD9CwO3X0m
 func FromPtrOr[T any](x *T, fallback T) T {
 	if x == nil {
 		return fallback
@@ -23,66 +68,147 @@ func FromPtrOr[T any](x *T, fallback T) T {
 	return *x
 }
 
-// ToSlicePtr returns a slice of pointer copy of value.
+// ToSlicePtr returns a slice of pointers to each value.
+// Play: https://go.dev/play/p/P2sD0PMXw4F
 func ToSlicePtr[T any](collection []T) []*T {
-	return Map(collection, func(x T, _ int) *T {
-		return &x
+	result := make([]*T, len(collection))
+
+	for i := range collection {
+		result[i] = &collection[i]
+	}
+	return result
+}
+
+// FromSlicePtr returns a slice with the pointer values.
+// Returns a zero value in case of a nil pointer element.
+// Play: https://go.dev/play/p/lbunFvzlUDX
+func FromSlicePtr[T any](collection []*T) []T {
+	return Map(collection, func(x *T, _ int) T {
+		if x == nil {
+			return Empty[T]()
+		}
+		return *x
 	})
 }
 
-// ToAnySlice returns a slice with all elements mapped to `any` type
+// FromSlicePtrOr returns a slice with the pointer values or the fallback value.
+// Play: https://go.dev/play/p/lbunFvzlUDX
+func FromSlicePtrOr[T any](collection []*T, fallback T) []T {
+	return Map(collection, func(x *T, _ int) T {
+		if x == nil {
+			return fallback
+		}
+		return *x
+	})
+}
+
+// ToAnySlice returns a slice with all elements mapped to `any` type.
+// Play: https://go.dev/play/p/P2sD0PMXw4F
 func ToAnySlice[T any](collection []T) []any {
 	result := make([]any, len(collection))
-	for i, item := range collection {
-		result[i] = item
+	for i := range collection {
+		result[i] = collection[i]
 	}
 	return result
 }
 
-// FromAnySlice returns an `any` slice with all elements mapped to a type.
+// FromAnySlice returns a slice with all elements mapped to a type.
 // Returns false in case of type conversion failure.
-func FromAnySlice[T any](in []any) (out []T, ok bool) {
-	defer func() {
-		if r := recover(); r != nil {
-			out = []T{}
-			ok = false
+// Play: https://go.dev/play/p/P2sD0PMXw4F
+func FromAnySlice[T any](in []any) ([]T, bool) {
+	out := make([]T, len(in))
+	for i := range in {
+		t, ok := in[i].(T)
+		if !ok {
+			return []T{}, false
 		}
-	}()
-
-	result := make([]T, len(in))
-	for i, item := range in {
-		result[i] = item.(T)
+		out[i] = t
 	}
-	return result, true
+	return out, true
 }
 
-// Empty returns an empty value.
+// Empty returns the zero value (https://go.dev/ref/spec#The_zero_value).
+// Play: https://go.dev/play/p/P2sD0PMXw4F
 func Empty[T any]() T {
 	var zero T
 	return zero
 }
 
 // IsEmpty returns true if argument is a zero value.
+// Play: https://go.dev/play/p/P2sD0PMXw4F
 func IsEmpty[T comparable](v T) bool {
 	var zero T
 	return zero == v
 }
 
 // IsNotEmpty returns true if argument is not a zero value.
+// Play: https://go.dev/play/p/P2sD0PMXw4F
 func IsNotEmpty[T comparable](v T) bool {
 	var zero T
 	return zero != v
 }
 
 // Coalesce returns the first non-empty arguments. Arguments must be comparable.
-func Coalesce[T comparable](v ...T) (result T, ok bool) {
-	for _, e := range v {
-		if e != result {
-			result = e
-			ok = true
-			return
+// Play: https://go.dev/play/p/Gyo9otyvFHH
+func Coalesce[T comparable](values ...T) (T, bool) {
+	var zero T
+
+	for i := range values {
+		if values[i] != zero {
+			return values[i], true
 		}
 	}
 
-	return
+	return zero, false
+}
+
+// CoalesceOrEmpty returns the first non-empty arguments. Arguments must be comparable.
+// Play: https://go.dev/play/p/Gyo9otyvFHH
+func CoalesceOrEmpty[T comparable](v ...T) T {
+	result, _ := Coalesce(v...)
+	return result
+}
+
+// CoalesceSlice returns the first non-zero slice.
+// Play: https://go.dev/play/p/Gyo9otyvFHH
+func CoalesceSlice[T any](v ...[]T) ([]T, bool) {
+	for i := range v {
+		if len(v[i]) > 0 {
+			return v[i], true
+		}
+	}
+	return []T{}, false
+}
+
+// CoalesceSliceOrEmpty returns the first non-zero slice.
+// Play: https://go.dev/play/p/Gyo9otyvFHH
+func CoalesceSliceOrEmpty[T any](v ...[]T) []T {
+	for i := range v {
+		if len(v[i]) > 0 {
+			return v[i]
+		}
+	}
+	return []T{}
+}
+
+// CoalesceMap returns the first non-zero map.
+// Play: https://go.dev/play/p/Gyo9otyvFHH
+func CoalesceMap[K comparable, V any](v ...map[K]V) (map[K]V, bool) {
+	for i := range v {
+		if len(v[i]) > 0 {
+			return v[i], true
+		}
+	}
+	return map[K]V{}, false
+}
+
+// CoalesceMapOrEmpty returns the first non-zero map.
+// Play: https://go.dev/play/p/Gyo9otyvFHH
+func CoalesceMapOrEmpty[K comparable, V any](v ...map[K]V) map[K]V {
+	for i := range v {
+		if len(v[i]) > 0 {
+			return v[i]
+		}
+	}
+	return map[K]V{}
 }
diff --git a/vendor/github.com/samber/lo/types.go b/vendor/github.com/samber/lo/types.go
index 5361a02a159..ccd3d07bce1 100644
--- a/vendor/github.com/samber/lo/types.go
+++ b/vendor/github.com/samber/lo/types.go
@@ -7,28 +7,46 @@ type Entry[K comparable, V any] struct {
 }
 
 // Tuple2 is a group of 2 elements (pair).
-type Tuple2[A any, B any] struct {
+type Tuple2[A, B any] struct {
 	A A
 	B B
 }
 
+// Unpack returns values contained in a tuple.
+// Play: https://go.dev/play/p/yrtn7QJTmL_E
+func (t Tuple2[A, B]) Unpack() (A, B) {
+	return t.A, t.B
+}
+
 // Tuple3 is a group of 3 elements.
-type Tuple3[A any, B any, C any] struct {
+type Tuple3[A, B, C any] struct {
 	A A
 	B B
 	C C
 }
 
+// Unpack returns values contained in a tuple.
+// Play: https://go.dev/play/p/yrtn7QJTmL_E
+func (t Tuple3[A, B, C]) Unpack() (A, B, C) {
+	return t.A, t.B, t.C
+}
+
 // Tuple4 is a group of 4 elements.
-type Tuple4[A any, B any, C any, D any] struct {
+type Tuple4[A, B, C, D any] struct {
 	A A
 	B B
 	C C
 	D D
 }
 
+// Unpack returns values contained in a tuple.
+// Play: https://go.dev/play/p/yrtn7QJTmL_E
+func (t Tuple4[A, B, C, D]) Unpack() (A, B, C, D) {
+	return t.A, t.B, t.C, t.D
+}
+
 // Tuple5 is a group of 5 elements.
-type Tuple5[A any, B any, C any, D any, E any] struct {
+type Tuple5[A, B, C, D, E any] struct {
 	A A
 	B B
 	C C
@@ -36,8 +54,14 @@ type Tuple5[A any, B any, C any, D any, E any] struct {
 	E E
 }
 
+// Unpack returns values contained in a tuple.
+// Play: https://go.dev/play/p/7J4KrtgtK3M
+func (t Tuple5[A, B, C, D, E]) Unpack() (A, B, C, D, E) {
+	return t.A, t.B, t.C, t.D, t.E
+}
+
 // Tuple6 is a group of 6 elements.
-type Tuple6[A any, B any, C any, D any, E any, F any] struct {
+type Tuple6[A, B, C, D, E, F any] struct {
 	A A
 	B B
 	C C
@@ -46,8 +70,14 @@ type Tuple6[A any, B any, C any, D any, E any, F any] struct {
 	F F
 }
 
+// Unpack returns values contained in a tuple.
+// Play: https://go.dev/play/p/7J4KrtgtK3M
+func (t Tuple6[A, B, C, D, E, F]) Unpack() (A, B, C, D, E, F) {
+	return t.A, t.B, t.C, t.D, t.E, t.F
+}
+
 // Tuple7 is a group of 7 elements.
-type Tuple7[A any, B any, C any, D any, E any, F any, G any] struct {
+type Tuple7[A, B, C, D, E, F, G any] struct {
 	A A
 	B B
 	C C
@@ -57,8 +87,14 @@ type Tuple7[A any, B any, C any, D any, E any, F any, G any] struct {
 	G G
 }
 
+// Unpack returns values contained in a tuple.
+// Play: https://go.dev/play/p/Ow9Zgf_zeiA
+func (t Tuple7[A, B, C, D, E, F, G]) Unpack() (A, B, C, D, E, F, G) {
+	return t.A, t.B, t.C, t.D, t.E, t.F, t.G
+}
+
 // Tuple8 is a group of 8 elements.
-type Tuple8[A any, B any, C any, D any, E any, F any, G any, H any] struct {
+type Tuple8[A, B, C, D, E, F, G, H any] struct {
 	A A
 	B B
 	C C
@@ -69,8 +105,14 @@ type Tuple8[A any, B any, C any, D any, E any, F any, G any, H any] struct {
 	H H
 }
 
+// Unpack returns values contained in a tuple.
+// Play: https://go.dev/play/p/Ow9Zgf_zeiA
+func (t Tuple8[A, B, C, D, E, F, G, H]) Unpack() (A, B, C, D, E, F, G, H) {
+	return t.A, t.B, t.C, t.D, t.E, t.F, t.G, t.H
+}
+
 // Tuple9 is a group of 9 elements.
-type Tuple9[A any, B any, C any, D any, E any, F any, G any, H any, I any] struct {
+type Tuple9[A, B, C, D, E, F, G, H, I any] struct {
 	A A
 	B B
 	C C
@@ -81,3 +123,9 @@ type Tuple9[A any, B any, C any, D any, E any, F any, G any, H any, I any] struc
 	H H
 	I I
 }
+
+// Unpack returns values contained in a tuple.
+// Play: https://go.dev/play/p/Ow9Zgf_zeiA
+func (t Tuple9[A, B, C, D, E, F, G, H, I]) Unpack() (A, B, C, D, E, F, G, H, I) {
+	return t.A, t.B, t.C, t.D, t.E, t.F, t.G, t.H, t.I
+}
diff --git a/vendor/golang.org/x/text/cases/cases.go b/vendor/golang.org/x/text/cases/cases.go
new file mode 100644
index 00000000000..752cdf03167
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/cases.go
@@ -0,0 +1,162 @@
+// Copyright 2014 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.
+
+//go:generate go run gen.go gen_trieval.go
+
+// Package cases provides general and language-specific case mappers.
+package cases // import "golang.org/x/text/cases"
+
+import (
+	"golang.org/x/text/language"
+	"golang.org/x/text/transform"
+)
+
+// References:
+// - Unicode Reference Manual Chapter 3.13, 4.2, and 5.18.
+// - https://www.unicode.org/reports/tr29/
+// - https://www.unicode.org/Public/6.3.0/ucd/CaseFolding.txt
+// - https://www.unicode.org/Public/6.3.0/ucd/SpecialCasing.txt
+// - https://www.unicode.org/Public/6.3.0/ucd/DerivedCoreProperties.txt
+// - https://www.unicode.org/Public/6.3.0/ucd/auxiliary/WordBreakProperty.txt
+// - https://www.unicode.org/Public/6.3.0/ucd/auxiliary/WordBreakTest.txt
+// - http://userguide.icu-project.org/transforms/casemappings
+
+// TODO:
+// - Case folding
+// - Wide and Narrow?
+// - Segmenter option for title casing.
+// - ASCII fast paths
+// - Encode Soft-Dotted property within trie somehow.
+
+// A Caser transforms given input to a certain case. It implements
+// transform.Transformer.
+//
+// A Caser may be stateful and should therefore not be shared between
+// goroutines.
+type Caser struct {
+	t transform.SpanningTransformer
+}
+
+// Bytes returns a new byte slice with the result of converting b to the case
+// form implemented by c.
+func (c Caser) Bytes(b []byte) []byte {
+	b, _, _ = transform.Bytes(c.t, b)
+	return b
+}
+
+// String returns a string with the result of transforming s to the case form
+// implemented by c.
+func (c Caser) String(s string) string {
+	s, _, _ = transform.String(c.t, s)
+	return s
+}
+
+// Reset resets the Caser to be reused for new input after a previous call to
+// Transform.
+func (c Caser) Reset() { c.t.Reset() }
+
+// Transform implements the transform.Transformer interface and transforms the
+// given input to the case form implemented by c.
+func (c Caser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	return c.t.Transform(dst, src, atEOF)
+}
+
+// Span implements the transform.SpanningTransformer interface.
+func (c Caser) Span(src []byte, atEOF bool) (n int, err error) {
+	return c.t.Span(src, atEOF)
+}
+
+// Upper returns a Caser for language-specific uppercasing.
+func Upper(t language.Tag, opts ...Option) Caser {
+	return Caser{makeUpper(t, getOpts(opts...))}
+}
+
+// Lower returns a Caser for language-specific lowercasing.
+func Lower(t language.Tag, opts ...Option) Caser {
+	return Caser{makeLower(t, getOpts(opts...))}
+}
+
+// Title returns a Caser for language-specific title casing. It uses an
+// approximation of the default Unicode Word Break algorithm.
+func Title(t language.Tag, opts ...Option) Caser {
+	return Caser{makeTitle(t, getOpts(opts...))}
+}
+
+// Fold returns a Caser that implements Unicode case folding. The returned Caser
+// is stateless and safe to use concurrently by multiple goroutines.
+//
+// Case folding does not normalize the input and may not preserve a normal form.
+// Use the collate or search package for more convenient and linguistically
+// sound comparisons. Use golang.org/x/text/secure/precis for string comparisons
+// where security aspects are a concern.
+func Fold(opts ...Option) Caser {
+	return Caser{makeFold(getOpts(opts...))}
+}
+
+// An Option is used to modify the behavior of a Caser.
+type Option func(o options) options
+
+// TODO: consider these options to take a boolean as well, like FinalSigma.
+// The advantage of using this approach is that other providers of a lower-case
+// algorithm could set different defaults by prefixing a user-provided slice
+// of options with their own. This is handy, for instance, for the precis
+// package which would override the default to not handle the Greek final sigma.
+
+var (
+	// NoLower disables the lowercasing of non-leading letters for a title
+	// caser.
+	NoLower Option = noLower
+
+	// Compact omits mappings in case folding for characters that would grow the
+	// input. (Unimplemented.)
+	Compact Option = compact
+)
+
+// TODO: option to preserve a normal form, if applicable?
+
+type options struct {
+	noLower bool
+	simple  bool
+
+	// TODO: segmenter, max ignorable, alternative versions, etc.
+
+	ignoreFinalSigma bool
+}
+
+func getOpts(o ...Option) (res options) {
+	for _, f := range o {
+		res = f(res)
+	}
+	return
+}
+
+func noLower(o options) options {
+	o.noLower = true
+	return o
+}
+
+func compact(o options) options {
+	o.simple = true
+	return o
+}
+
+// HandleFinalSigma specifies whether the special handling of Greek final sigma
+// should be enabled. Unicode prescribes handling the Greek final sigma for all
+// locales, but standards like IDNA and PRECIS override this default.
+func HandleFinalSigma(enable bool) Option {
+	if enable {
+		return handleFinalSigma
+	}
+	return ignoreFinalSigma
+}
+
+func ignoreFinalSigma(o options) options {
+	o.ignoreFinalSigma = true
+	return o
+}
+
+func handleFinalSigma(o options) options {
+	o.ignoreFinalSigma = false
+	return o
+}
diff --git a/vendor/golang.org/x/text/cases/context.go b/vendor/golang.org/x/text/cases/context.go
new file mode 100644
index 00000000000..e9aa9e1936f
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/context.go
@@ -0,0 +1,376 @@
+// Copyright 2014 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 cases
+
+import "golang.org/x/text/transform"
+
+// A context is used for iterating over source bytes, fetching case info and
+// writing to a destination buffer.
+//
+// Casing operations may need more than one rune of context to decide how a rune
+// should be cased. Casing implementations should call checkpoint on context
+// whenever it is known to be safe to return the runes processed so far.
+//
+// It is recommended for implementations to not allow for more than 30 case
+// ignorables as lookahead (analogous to the limit in norm) and to use state if
+// unbounded lookahead is needed for cased runes.
+type context struct {
+	dst, src []byte
+	atEOF    bool
+
+	pDst int // pDst points past the last written rune in dst.
+	pSrc int // pSrc points to the start of the currently scanned rune.
+
+	// checkpoints safe to return in Transform, where nDst <= pDst and nSrc <= pSrc.
+	nDst, nSrc int
+	err        error
+
+	sz   int  // size of current rune
+	info info // case information of currently scanned rune
+
+	// State preserved across calls to Transform.
+	isMidWord bool // false if next cased letter needs to be title-cased.
+}
+
+func (c *context) Reset() {
+	c.isMidWord = false
+}
+
+// ret returns the return values for the Transform method. It checks whether
+// there were insufficient bytes in src to complete and introduces an error
+// accordingly, if necessary.
+func (c *context) ret() (nDst, nSrc int, err error) {
+	if c.err != nil || c.nSrc == len(c.src) {
+		return c.nDst, c.nSrc, c.err
+	}
+	// This point is only reached by mappers if there was no short destination
+	// buffer. This means that the source buffer was exhausted and that c.sz was
+	// set to 0 by next.
+	if c.atEOF && c.pSrc == len(c.src) {
+		return c.pDst, c.pSrc, nil
+	}
+	return c.nDst, c.nSrc, transform.ErrShortSrc
+}
+
+// retSpan returns the return values for the Span method. It checks whether
+// there were insufficient bytes in src to complete and introduces an error
+// accordingly, if necessary.
+func (c *context) retSpan() (n int, err error) {
+	_, nSrc, err := c.ret()
+	return nSrc, err
+}
+
+// checkpoint sets the return value buffer points for Transform to the current
+// positions.
+func (c *context) checkpoint() {
+	if c.err == nil {
+		c.nDst, c.nSrc = c.pDst, c.pSrc+c.sz
+	}
+}
+
+// unreadRune causes the last rune read by next to be reread on the next
+// invocation of next. Only one unreadRune may be called after a call to next.
+func (c *context) unreadRune() {
+	c.sz = 0
+}
+
+func (c *context) next() bool {
+	c.pSrc += c.sz
+	if c.pSrc == len(c.src) || c.err != nil {
+		c.info, c.sz = 0, 0
+		return false
+	}
+	v, sz := trie.lookup(c.src[c.pSrc:])
+	c.info, c.sz = info(v), sz
+	if c.sz == 0 {
+		if c.atEOF {
+			// A zero size means we have an incomplete rune. If we are atEOF,
+			// this means it is an illegal rune, which we will consume one
+			// byte at a time.
+			c.sz = 1
+		} else {
+			c.err = transform.ErrShortSrc
+			return false
+		}
+	}
+	return true
+}
+
+// writeBytes adds bytes to dst.
+func (c *context) writeBytes(b []byte) bool {
+	if len(c.dst)-c.pDst < len(b) {
+		c.err = transform.ErrShortDst
+		return false
+	}
+	// This loop is faster than using copy.
+	for _, ch := range b {
+		c.dst[c.pDst] = ch
+		c.pDst++
+	}
+	return true
+}
+
+// writeString writes the given string to dst.
+func (c *context) writeString(s string) bool {
+	if len(c.dst)-c.pDst < len(s) {
+		c.err = transform.ErrShortDst
+		return false
+	}
+	// This loop is faster than using copy.
+	for i := 0; i < len(s); i++ {
+		c.dst[c.pDst] = s[i]
+		c.pDst++
+	}
+	return true
+}
+
+// copy writes the current rune to dst.
+func (c *context) copy() bool {
+	return c.writeBytes(c.src[c.pSrc : c.pSrc+c.sz])
+}
+
+// copyXOR copies the current rune to dst and modifies it by applying the XOR
+// pattern of the case info. It is the responsibility of the caller to ensure
+// that this is a rune with a XOR pattern defined.
+func (c *context) copyXOR() bool {
+	if !c.copy() {
+		return false
+	}
+	if c.info&xorIndexBit == 0 {
+		// Fast path for 6-bit XOR pattern, which covers most cases.
+		c.dst[c.pDst-1] ^= byte(c.info >> xorShift)
+	} else {
+		// Interpret XOR bits as an index.
+		// TODO: test performance for unrolling this loop. Verify that we have
+		// at least two bytes and at most three.
+		idx := c.info >> xorShift
+		for p := c.pDst - 1; ; p-- {
+			c.dst[p] ^= xorData[idx]
+			idx--
+			if xorData[idx] == 0 {
+				break
+			}
+		}
+	}
+	return true
+}
+
+// hasPrefix returns true if src[pSrc:] starts with the given string.
+func (c *context) hasPrefix(s string) bool {
+	b := c.src[c.pSrc:]
+	if len(b) < len(s) {
+		return false
+	}
+	for i, c := range b[:len(s)] {
+		if c != s[i] {
+			return false
+		}
+	}
+	return true
+}
+
+// caseType returns an info with only the case bits, normalized to either
+// cLower, cUpper, cTitle or cUncased.
+func (c *context) caseType() info {
+	cm := c.info & 0x7
+	if cm < 4 {
+		return cm
+	}
+	if cm >= cXORCase {
+		// xor the last bit of the rune with the case type bits.
+		b := c.src[c.pSrc+c.sz-1]
+		return info(b&1) ^ cm&0x3
+	}
+	if cm == cIgnorableCased {
+		return cLower
+	}
+	return cUncased
+}
+
+// lower writes the lowercase version of the current rune to dst.
+func lower(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cLower {
+		return c.copy()
+	}
+	if c.info&exceptionBit == 0 {
+		return c.copyXOR()
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	offset := 2 + e[0]&lengthMask // size of header + fold string
+	if nLower := (e[1] >> lengthBits) & lengthMask; nLower != noChange {
+		return c.writeString(e[offset : offset+nLower])
+	}
+	return c.copy()
+}
+
+func isLower(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cLower {
+		return true
+	}
+	if c.info&exceptionBit == 0 {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	if nLower := (e[1] >> lengthBits) & lengthMask; nLower != noChange {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	return true
+}
+
+// upper writes the uppercase version of the current rune to dst.
+func upper(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cUpper {
+		return c.copy()
+	}
+	if c.info&exceptionBit == 0 {
+		return c.copyXOR()
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	offset := 2 + e[0]&lengthMask // size of header + fold string
+	// Get length of first special case mapping.
+	n := (e[1] >> lengthBits) & lengthMask
+	if ct == cTitle {
+		// The first special case mapping is for lower. Set n to the second.
+		if n == noChange {
+			n = 0
+		}
+		n, e = e[1]&lengthMask, e[n:]
+	}
+	if n != noChange {
+		return c.writeString(e[offset : offset+n])
+	}
+	return c.copy()
+}
+
+// isUpper writes the isUppercase version of the current rune to dst.
+func isUpper(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cUpper {
+		return true
+	}
+	if c.info&exceptionBit == 0 {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	// Get length of first special case mapping.
+	n := (e[1] >> lengthBits) & lengthMask
+	if ct == cTitle {
+		n = e[1] & lengthMask
+	}
+	if n != noChange {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	return true
+}
+
+// title writes the title case version of the current rune to dst.
+func title(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cTitle {
+		return c.copy()
+	}
+	if c.info&exceptionBit == 0 {
+		if ct == cLower {
+			return c.copyXOR()
+		}
+		return c.copy()
+	}
+	// Get the exception data.
+	e := exceptions[c.info>>exceptionShift:]
+	offset := 2 + e[0]&lengthMask // size of header + fold string
+
+	nFirst := (e[1] >> lengthBits) & lengthMask
+	if nTitle := e[1] & lengthMask; nTitle != noChange {
+		if nFirst != noChange {
+			e = e[nFirst:]
+		}
+		return c.writeString(e[offset : offset+nTitle])
+	}
+	if ct == cLower && nFirst != noChange {
+		// Use the uppercase version instead.
+		return c.writeString(e[offset : offset+nFirst])
+	}
+	// Already in correct case.
+	return c.copy()
+}
+
+// isTitle reports whether the current rune is in title case.
+func isTitle(c *context) bool {
+	ct := c.caseType()
+	if c.info&hasMappingMask == 0 || ct == cTitle {
+		return true
+	}
+	if c.info&exceptionBit == 0 {
+		if ct == cLower {
+			c.err = transform.ErrEndOfSpan
+			return false
+		}
+		return true
+	}
+	// Get the exception data.
+	e := exceptions[c.info>>exceptionShift:]
+	if nTitle := e[1] & lengthMask; nTitle != noChange {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	nFirst := (e[1] >> lengthBits) & lengthMask
+	if ct == cLower && nFirst != noChange {
+		c.err = transform.ErrEndOfSpan
+		return false
+	}
+	return true
+}
+
+// foldFull writes the foldFull version of the current rune to dst.
+func foldFull(c *context) bool {
+	if c.info&hasMappingMask == 0 {
+		return c.copy()
+	}
+	ct := c.caseType()
+	if c.info&exceptionBit == 0 {
+		if ct != cLower || c.info&inverseFoldBit != 0 {
+			return c.copyXOR()
+		}
+		return c.copy()
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	n := e[0] & lengthMask
+	if n == 0 {
+		if ct == cLower {
+			return c.copy()
+		}
+		n = (e[1] >> lengthBits) & lengthMask
+	}
+	return c.writeString(e[2 : 2+n])
+}
+
+// isFoldFull reports whether the current run is mapped to foldFull
+func isFoldFull(c *context) bool {
+	if c.info&hasMappingMask == 0 {
+		return true
+	}
+	ct := c.caseType()
+	if c.info&exceptionBit == 0 {
+		if ct != cLower || c.info&inverseFoldBit != 0 {
+			c.err = transform.ErrEndOfSpan
+			return false
+		}
+		return true
+	}
+	e := exceptions[c.info>>exceptionShift:]
+	n := e[0] & lengthMask
+	if n == 0 && ct == cLower {
+		return true
+	}
+	c.err = transform.ErrEndOfSpan
+	return false
+}
diff --git a/vendor/golang.org/x/text/cases/fold.go b/vendor/golang.org/x/text/cases/fold.go
new file mode 100644
index 00000000000..85cc434fac0
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/fold.go
@@ -0,0 +1,34 @@
+// Copyright 2016 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 cases
+
+import "golang.org/x/text/transform"
+
+type caseFolder struct{ transform.NopResetter }
+
+// caseFolder implements the Transformer interface for doing case folding.
+func (t *caseFolder) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	c := context{dst: dst, src: src, atEOF: atEOF}
+	for c.next() {
+		foldFull(&c)
+		c.checkpoint()
+	}
+	return c.ret()
+}
+
+func (t *caseFolder) Span(src []byte, atEOF bool) (n int, err error) {
+	c := context{src: src, atEOF: atEOF}
+	for c.next() && isFoldFull(&c) {
+		c.checkpoint()
+	}
+	return c.retSpan()
+}
+
+func makeFold(o options) transform.SpanningTransformer {
+	// TODO: Special case folding, through option Language, Special/Turkic, or
+	// both.
+	// TODO: Implement Compact options.
+	return &caseFolder{}
+}
diff --git a/vendor/golang.org/x/text/cases/icu.go b/vendor/golang.org/x/text/cases/icu.go
new file mode 100644
index 00000000000..db7c237ccff
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/icu.go
@@ -0,0 +1,61 @@
+// Copyright 2016 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.
+
+//go:build icu
+
+package cases
+
+// Ideally these functions would be defined in a test file, but go test doesn't
+// allow CGO in tests. The build tag should ensure either way that these
+// functions will not end up in the package.
+
+// TODO: Ensure that the correct ICU version is set.
+
+/*
+#cgo LDFLAGS: -licui18n.57 -licuuc.57
+#include <stdlib.h>
+#include <unicode/ustring.h>
+#include <unicode/utypes.h>
+#include <unicode/localpointer.h>
+#include <unicode/ucasemap.h>
+*/
+import "C"
+
+import "unsafe"
+
+func doICU(tag, caser, input string) string {
+	err := C.UErrorCode(0)
+	loc := C.CString(tag)
+	cm := C.ucasemap_open(loc, C.uint32_t(0), &err)
+
+	buf := make([]byte, len(input)*4)
+	dst := (*C.char)(unsafe.Pointer(&buf[0]))
+	src := C.CString(input)
+
+	cn := C.int32_t(0)
+
+	switch caser {
+	case "fold":
+		cn = C.ucasemap_utf8FoldCase(cm,
+			dst, C.int32_t(len(buf)),
+			src, C.int32_t(len(input)),
+			&err)
+	case "lower":
+		cn = C.ucasemap_utf8ToLower(cm,
+			dst, C.int32_t(len(buf)),
+			src, C.int32_t(len(input)),
+			&err)
+	case "upper":
+		cn = C.ucasemap_utf8ToUpper(cm,
+			dst, C.int32_t(len(buf)),
+			src, C.int32_t(len(input)),
+			&err)
+	case "title":
+		cn = C.ucasemap_utf8ToTitle(cm,
+			dst, C.int32_t(len(buf)),
+			src, C.int32_t(len(input)),
+			&err)
+	}
+	return string(buf[:cn])
+}
diff --git a/vendor/golang.org/x/text/cases/info.go b/vendor/golang.org/x/text/cases/info.go
new file mode 100644
index 00000000000..87a7c3e9557
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/info.go
@@ -0,0 +1,82 @@
+// Copyright 2015 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 cases
+
+func (c info) cccVal() info {
+	if c&exceptionBit != 0 {
+		return info(exceptions[c>>exceptionShift]) & cccMask
+	}
+	return c & cccMask
+}
+
+func (c info) cccType() info {
+	ccc := c.cccVal()
+	if ccc <= cccZero {
+		return cccZero
+	}
+	return ccc
+}
+
+// TODO: Implement full Unicode breaking algorithm:
+// 1) Implement breaking in separate package.
+// 2) Use the breaker here.
+// 3) Compare table size and performance of using the more generic breaker.
+//
+// Note that we can extend the current algorithm to be much more accurate. This
+// only makes sense, though, if the performance and/or space penalty of using
+// the generic breaker is big. Extra data will only be needed for non-cased
+// runes, which means there are sufficient bits left in the caseType.
+// ICU prohibits breaking in such cases as well.
+
+// For the purpose of title casing we use an approximation of the Unicode Word
+// Breaking algorithm defined in Annex #29:
+// https://www.unicode.org/reports/tr29/#Default_Grapheme_Cluster_Table.
+//
+// For our approximation, we group the Word Break types into the following
+// categories, with associated rules:
+//
+// 1) Letter:
+//    ALetter, Hebrew_Letter, Numeric, ExtendNumLet, Extend, Format_FE, ZWJ.
+//    Rule: Never break between consecutive runes of this category.
+//
+// 2) Mid:
+//    MidLetter, MidNumLet, Single_Quote.
+//    (Cf. case-ignorable: MidLetter, MidNumLet, Single_Quote or cat is Mn,
+//    Me, Cf, Lm or Sk).
+//    Rule: Don't break between Letter and Mid, but break between two Mids.
+//
+// 3) Break:
+//    Any other category: NewLine, MidNum, CR, LF, Double_Quote, Katakana, and
+//    Other.
+//    These categories should always result in a break between two cased letters.
+//    Rule: Always break.
+//
+// Note 1: the Katakana and MidNum categories can, in esoteric cases, result in
+// preventing a break between two cased letters. For now we will ignore this
+// (e.g. [ALetter] [ExtendNumLet] [Katakana] [ExtendNumLet] [ALetter] and
+// [ALetter] [Numeric] [MidNum] [Numeric] [ALetter].)
+//
+// Note 2: the rule for Mid is very approximate, but works in most cases. To
+// improve, we could store the categories in the trie value and use a FA to
+// manage breaks. See TODO comment above.
+//
+// Note 3: according to the spec, it is possible for the Extend category to
+// introduce breaks between other categories grouped in Letter. However, this
+// is undesirable for our purposes. ICU prevents breaks in such cases as well.
+
+// isBreak returns whether this rune should introduce a break.
+func (c info) isBreak() bool {
+	return c.cccVal() == cccBreak
+}
+
+// isLetter returns whether the rune is of break type ALetter, Hebrew_Letter,
+// Numeric, ExtendNumLet, or Extend.
+func (c info) isLetter() bool {
+	ccc := c.cccVal()
+	if ccc == cccZero {
+		return !c.isCaseIgnorable()
+	}
+	return ccc != cccBreak
+}
diff --git a/vendor/golang.org/x/text/cases/map.go b/vendor/golang.org/x/text/cases/map.go
new file mode 100644
index 00000000000..0f7c6a14bb7
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/map.go
@@ -0,0 +1,816 @@
+// Copyright 2014 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 cases
+
+// This file contains the definitions of case mappings for all supported
+// languages. The rules for the language-specific tailorings were taken and
+// modified from the CLDR transform definitions in common/transforms.
+
+import (
+	"strings"
+	"unicode"
+	"unicode/utf8"
+
+	"golang.org/x/text/internal"
+	"golang.org/x/text/language"
+	"golang.org/x/text/transform"
+	"golang.org/x/text/unicode/norm"
+)
+
+// A mapFunc takes a context set to the current rune and writes the mapped
+// version to the same context. It may advance the context to the next rune. It
+// returns whether a checkpoint is possible: whether the pDst bytes written to
+// dst so far won't need changing as we see more source bytes.
+type mapFunc func(*context) bool
+
+// A spanFunc takes a context set to the current rune and returns whether this
+// rune would be altered when written to the output. It may advance the context
+// to the next rune. It returns whether a checkpoint is possible.
+type spanFunc func(*context) bool
+
+// maxIgnorable defines the maximum number of ignorables to consider for
+// lookahead operations.
+const maxIgnorable = 30
+
+// supported lists the language tags for which we have tailorings.
+const supported = "und af az el lt nl tr"
+
+func init() {
+	tags := []language.Tag{}
+	for _, s := range strings.Split(supported, " ") {
+		tags = append(tags, language.MustParse(s))
+	}
+	matcher = internal.NewInheritanceMatcher(tags)
+	Supported = language.NewCoverage(tags)
+}
+
+var (
+	matcher *internal.InheritanceMatcher
+
+	Supported language.Coverage
+
+	// We keep the following lists separate, instead of having a single per-
+	// language struct, to give the compiler a chance to remove unused code.
+
+	// Some uppercase mappers are stateless, so we can precompute the
+	// Transformers and save a bit on runtime allocations.
+	upperFunc = []struct {
+		upper mapFunc
+		span  spanFunc
+	}{
+		{nil, nil},                  // und
+		{nil, nil},                  // af
+		{aztrUpper(upper), isUpper}, // az
+		{elUpper, noSpan},           // el
+		{ltUpper(upper), noSpan},    // lt
+		{nil, nil},                  // nl
+		{aztrUpper(upper), isUpper}, // tr
+	}
+
+	undUpper            transform.SpanningTransformer = &undUpperCaser{}
+	undLower            transform.SpanningTransformer = &undLowerCaser{}
+	undLowerIgnoreSigma transform.SpanningTransformer = &undLowerIgnoreSigmaCaser{}
+
+	lowerFunc = []mapFunc{
+		nil,       // und
+		nil,       // af
+		aztrLower, // az
+		nil,       // el
+		ltLower,   // lt
+		nil,       // nl
+		aztrLower, // tr
+	}
+
+	titleInfos = []struct {
+		title     mapFunc
+		lower     mapFunc
+		titleSpan spanFunc
+		rewrite   func(*context)
+	}{
+		{title, lower, isTitle, nil},                // und
+		{title, lower, isTitle, afnlRewrite},        // af
+		{aztrUpper(title), aztrLower, isTitle, nil}, // az
+		{title, lower, isTitle, nil},                // el
+		{ltUpper(title), ltLower, noSpan, nil},      // lt
+		{nlTitle, lower, nlTitleSpan, afnlRewrite},  // nl
+		{aztrUpper(title), aztrLower, isTitle, nil}, // tr
+	}
+)
+
+func makeUpper(t language.Tag, o options) transform.SpanningTransformer {
+	_, i, _ := matcher.Match(t)
+	f := upperFunc[i].upper
+	if f == nil {
+		return undUpper
+	}
+	return &simpleCaser{f: f, span: upperFunc[i].span}
+}
+
+func makeLower(t language.Tag, o options) transform.SpanningTransformer {
+	_, i, _ := matcher.Match(t)
+	f := lowerFunc[i]
+	if f == nil {
+		if o.ignoreFinalSigma {
+			return undLowerIgnoreSigma
+		}
+		return undLower
+	}
+	if o.ignoreFinalSigma {
+		return &simpleCaser{f: f, span: isLower}
+	}
+	return &lowerCaser{
+		first:   f,
+		midWord: finalSigma(f),
+	}
+}
+
+func makeTitle(t language.Tag, o options) transform.SpanningTransformer {
+	_, i, _ := matcher.Match(t)
+	x := &titleInfos[i]
+	lower := x.lower
+	if o.noLower {
+		lower = (*context).copy
+	} else if !o.ignoreFinalSigma {
+		lower = finalSigma(lower)
+	}
+	return &titleCaser{
+		title:     x.title,
+		lower:     lower,
+		titleSpan: x.titleSpan,
+		rewrite:   x.rewrite,
+	}
+}
+
+func noSpan(c *context) bool {
+	c.err = transform.ErrEndOfSpan
+	return false
+}
+
+// TODO: consider a similar special case for the fast majority lower case. This
+// is a bit more involved so will require some more precise benchmarking to
+// justify it.
+
+type undUpperCaser struct{ transform.NopResetter }
+
+// undUpperCaser implements the Transformer interface for doing an upper case
+// mapping for the root locale (und). It eliminates the need for an allocation
+// as it prevents escaping by not using function pointers.
+func (t undUpperCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	c := context{dst: dst, src: src, atEOF: atEOF}
+	for c.next() {
+		upper(&c)
+		c.checkpoint()
+	}
+	return c.ret()
+}
+
+func (t undUpperCaser) Span(src []byte, atEOF bool) (n int, err error) {
+	c := context{src: src, atEOF: atEOF}
+	for c.next() && isUpper(&c) {
+		c.checkpoint()
+	}
+	return c.retSpan()
+}
+
+// undLowerIgnoreSigmaCaser implements the Transformer interface for doing
+// a lower case mapping for the root locale (und) ignoring final sigma
+// handling. This casing algorithm is used in some performance-critical packages
+// like secure/precis and x/net/http/idna, which warrants its special-casing.
+type undLowerIgnoreSigmaCaser struct{ transform.NopResetter }
+
+func (t undLowerIgnoreSigmaCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	c := context{dst: dst, src: src, atEOF: atEOF}
+	for c.next() && lower(&c) {
+		c.checkpoint()
+	}
+	return c.ret()
+
+}
+
+// Span implements a generic lower-casing. This is possible as isLower works
+// for all lowercasing variants. All lowercase variants only vary in how they
+// transform a non-lowercase letter. They will never change an already lowercase
+// letter. In addition, there is no state.
+func (t undLowerIgnoreSigmaCaser) Span(src []byte, atEOF bool) (n int, err error) {
+	c := context{src: src, atEOF: atEOF}
+	for c.next() && isLower(&c) {
+		c.checkpoint()
+	}
+	return c.retSpan()
+}
+
+type simpleCaser struct {
+	context
+	f    mapFunc
+	span spanFunc
+}
+
+// simpleCaser implements the Transformer interface for doing a case operation
+// on a rune-by-rune basis.
+func (t *simpleCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	c := context{dst: dst, src: src, atEOF: atEOF}
+	for c.next() && t.f(&c) {
+		c.checkpoint()
+	}
+	return c.ret()
+}
+
+func (t *simpleCaser) Span(src []byte, atEOF bool) (n int, err error) {
+	c := context{src: src, atEOF: atEOF}
+	for c.next() && t.span(&c) {
+		c.checkpoint()
+	}
+	return c.retSpan()
+}
+
+// undLowerCaser implements the Transformer interface for doing a lower case
+// mapping for the root locale (und) ignoring final sigma handling. This casing
+// algorithm is used in some performance-critical packages like secure/precis
+// and x/net/http/idna, which warrants its special-casing.
+type undLowerCaser struct{ transform.NopResetter }
+
+func (t undLowerCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	c := context{dst: dst, src: src, atEOF: atEOF}
+
+	for isInterWord := true; c.next(); {
+		if isInterWord {
+			if c.info.isCased() {
+				if !lower(&c) {
+					break
+				}
+				isInterWord = false
+			} else if !c.copy() {
+				break
+			}
+		} else {
+			if c.info.isNotCasedAndNotCaseIgnorable() {
+				if !c.copy() {
+					break
+				}
+				isInterWord = true
+			} else if !c.hasPrefix("Σ") {
+				if !lower(&c) {
+					break
+				}
+			} else if !finalSigmaBody(&c) {
+				break
+			}
+		}
+		c.checkpoint()
+	}
+	return c.ret()
+}
+
+func (t undLowerCaser) Span(src []byte, atEOF bool) (n int, err error) {
+	c := context{src: src, atEOF: atEOF}
+	for c.next() && isLower(&c) {
+		c.checkpoint()
+	}
+	return c.retSpan()
+}
+
+// lowerCaser implements the Transformer interface. The default Unicode lower
+// casing requires different treatment for the first and subsequent characters
+// of a word, most notably to handle the Greek final Sigma.
+type lowerCaser struct {
+	undLowerIgnoreSigmaCaser
+
+	context
+
+	first, midWord mapFunc
+}
+
+func (t *lowerCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	t.context = context{dst: dst, src: src, atEOF: atEOF}
+	c := &t.context
+
+	for isInterWord := true; c.next(); {
+		if isInterWord {
+			if c.info.isCased() {
+				if !t.first(c) {
+					break
+				}
+				isInterWord = false
+			} else if !c.copy() {
+				break
+			}
+		} else {
+			if c.info.isNotCasedAndNotCaseIgnorable() {
+				if !c.copy() {
+					break
+				}
+				isInterWord = true
+			} else if !t.midWord(c) {
+				break
+			}
+		}
+		c.checkpoint()
+	}
+	return c.ret()
+}
+
+// titleCaser implements the Transformer interface. Title casing algorithms
+// distinguish between the first letter of a word and subsequent letters of the
+// same word. It uses state to avoid requiring a potentially infinite lookahead.
+type titleCaser struct {
+	context
+
+	// rune mappings used by the actual casing algorithms.
+	title     mapFunc
+	lower     mapFunc
+	titleSpan spanFunc
+
+	rewrite func(*context)
+}
+
+// Transform implements the standard Unicode title case algorithm as defined in
+// Chapter 3 of The Unicode Standard:
+// toTitlecase(X): Find the word boundaries in X according to Unicode Standard
+// Annex #29, "Unicode Text Segmentation." For each word boundary, find the
+// first cased character F following the word boundary. If F exists, map F to
+// Titlecase_Mapping(F); then map all characters C between F and the following
+// word boundary to Lowercase_Mapping(C).
+func (t *titleCaser) Transform(dst, src []byte, atEOF bool) (nDst, nSrc int, err error) {
+	t.context = context{dst: dst, src: src, atEOF: atEOF, isMidWord: t.isMidWord}
+	c := &t.context
+
+	if !c.next() {
+		return c.ret()
+	}
+
+	for {
+		p := c.info
+		if t.rewrite != nil {
+			t.rewrite(c)
+		}
+
+		wasMid := p.isMid()
+		// Break out of this loop on failure to ensure we do not modify the
+		// state incorrectly.
+		if p.isCased() {
+			if !c.isMidWord {
+				if !t.title(c) {
+					break
+				}
+				c.isMidWord = true
+			} else if !t.lower(c) {
+				break
+			}
+		} else if !c.copy() {
+			break
+		} else if p.isBreak() {
+			c.isMidWord = false
+		}
+
+		// As we save the state of the transformer, it is safe to call
+		// checkpoint after any successful write.
+		if !(c.isMidWord && wasMid) {
+			c.checkpoint()
+		}
+
+		if !c.next() {
+			break
+		}
+		if wasMid && c.info.isMid() {
+			c.isMidWord = false
+		}
+	}
+	return c.ret()
+}
+
+func (t *titleCaser) Span(src []byte, atEOF bool) (n int, err error) {
+	t.context = context{src: src, atEOF: atEOF, isMidWord: t.isMidWord}
+	c := &t.context
+
+	if !c.next() {
+		return c.retSpan()
+	}
+
+	for {
+		p := c.info
+		if t.rewrite != nil {
+			t.rewrite(c)
+		}
+
+		wasMid := p.isMid()
+		// Break out of this loop on failure to ensure we do not modify the
+		// state incorrectly.
+		if p.isCased() {
+			if !c.isMidWord {
+				if !t.titleSpan(c) {
+					break
+				}
+				c.isMidWord = true
+			} else if !isLower(c) {
+				break
+			}
+		} else if p.isBreak() {
+			c.isMidWord = false
+		}
+		// As we save the state of the transformer, it is safe to call
+		// checkpoint after any successful write.
+		if !(c.isMidWord && wasMid) {
+			c.checkpoint()
+		}
+
+		if !c.next() {
+			break
+		}
+		if wasMid && c.info.isMid() {
+			c.isMidWord = false
+		}
+	}
+	return c.retSpan()
+}
+
+// finalSigma adds Greek final Sigma handing to another casing function. It
+// determines whether a lowercased sigma should be σ or ς, by looking ahead for
+// case-ignorables and a cased letters.
+func finalSigma(f mapFunc) mapFunc {
+	return func(c *context) bool {
+		if !c.hasPrefix("Σ") {
+			return f(c)
+		}
+		return finalSigmaBody(c)
+	}
+}
+
+func finalSigmaBody(c *context) bool {
+	// Current rune must be ∑.
+
+	// ::NFD();
+	// # 03A3; 03C2; 03A3; 03A3; Final_Sigma; # GREEK CAPITAL LETTER SIGMA
+	// Σ } [:case-ignorable:]* [:cased:] → σ;
+	// [:cased:] [:case-ignorable:]* { Σ → ς;
+	// ::Any-Lower;
+	// ::NFC();
+
+	p := c.pDst
+	c.writeString("ς")
+
+	// TODO: we should do this here, but right now this will never have an
+	// effect as this is called when the prefix is Sigma, whereas Dutch and
+	// Afrikaans only test for an apostrophe.
+	//
+	// if t.rewrite != nil {
+	// 	t.rewrite(c)
+	// }
+
+	// We need to do one more iteration after maxIgnorable, as a cased
+	// letter is not an ignorable and may modify the result.
+	wasMid := false
+	for i := 0; i < maxIgnorable+1; i++ {
+		if !c.next() {
+			return false
+		}
+		if !c.info.isCaseIgnorable() {
+			// All Midword runes are also case ignorable, so we are
+			// guaranteed to have a letter or word break here. As we are
+			// unreading the run, there is no need to unset c.isMidWord;
+			// the title caser will handle this.
+			if c.info.isCased() {
+				// p+1 is guaranteed to be in bounds: if writing ς was
+				// successful, p+1 will contain the second byte of ς. If not,
+				// this function will have returned after c.next returned false.
+				c.dst[p+1]++ // ς → σ
+			}
+			c.unreadRune()
+			return true
+		}
+		// A case ignorable may also introduce a word break, so we may need
+		// to continue searching even after detecting a break.
+		isMid := c.info.isMid()
+		if (wasMid && isMid) || c.info.isBreak() {
+			c.isMidWord = false
+		}
+		wasMid = isMid
+		c.copy()
+	}
+	return true
+}
+
+// finalSigmaSpan would be the same as isLower.
+
+// elUpper implements Greek upper casing, which entails removing a predefined
+// set of non-blocked modifiers. Note that these accents should not be removed
+// for title casing!
+// Example: "Οδός" -> "ΟΔΟΣ".
+func elUpper(c *context) bool {
+	// From CLDR:
+	// [:Greek:] [^[:ccc=Not_Reordered:][:ccc=Above:]]*? { [\u0313\u0314\u0301\u0300\u0306\u0342\u0308\u0304] → ;
+	// [:Greek:] [^[:ccc=Not_Reordered:][:ccc=Iota_Subscript:]]*? { \u0345 → ;
+
+	r, _ := utf8.DecodeRune(c.src[c.pSrc:])
+	oldPDst := c.pDst
+	if !upper(c) {
+		return false
+	}
+	if !unicode.Is(unicode.Greek, r) {
+		return true
+	}
+	i := 0
+	// Take the properties of the uppercased rune that is already written to the
+	// destination. This saves us the trouble of having to uppercase the
+	// decomposed rune again.
+	if b := norm.NFD.Properties(c.dst[oldPDst:]).Decomposition(); b != nil {
+		// Restore the destination position and process the decomposed rune.
+		r, sz := utf8.DecodeRune(b)
+		if r <= 0xFF { // See A.6.1
+			return true
+		}
+		c.pDst = oldPDst
+		// Insert the first rune and ignore the modifiers. See A.6.2.
+		c.writeBytes(b[:sz])
+		i = len(b[sz:]) / 2 // Greek modifiers are always of length 2.
+	}
+
+	for ; i < maxIgnorable && c.next(); i++ {
+		switch r, _ := utf8.DecodeRune(c.src[c.pSrc:]); r {
+		// Above and Iota Subscript
+		case 0x0300, // U+0300 COMBINING GRAVE ACCENT
+			0x0301, // U+0301 COMBINING ACUTE ACCENT
+			0x0304, // U+0304 COMBINING MACRON
+			0x0306, // U+0306 COMBINING BREVE
+			0x0308, // U+0308 COMBINING DIAERESIS
+			0x0313, // U+0313 COMBINING COMMA ABOVE
+			0x0314, // U+0314 COMBINING REVERSED COMMA ABOVE
+			0x0342, // U+0342 COMBINING GREEK PERISPOMENI
+			0x0345: // U+0345 COMBINING GREEK YPOGEGRAMMENI
+			// No-op. Gobble the modifier.
+
+		default:
+			switch v, _ := trie.lookup(c.src[c.pSrc:]); info(v).cccType() {
+			case cccZero:
+				c.unreadRune()
+				return true
+
+			// We don't need to test for IotaSubscript as the only rune that
+			// qualifies (U+0345) was already excluded in the switch statement
+			// above. See A.4.
+
+			case cccAbove:
+				return c.copy()
+			default:
+				// Some other modifier. We're still allowed to gobble Greek
+				// modifiers after this.
+				c.copy()
+			}
+		}
+	}
+	return i == maxIgnorable
+}
+
+// TODO: implement elUpperSpan (low-priority: complex and infrequent).
+
+func ltLower(c *context) bool {
+	// From CLDR:
+	// # Introduce an explicit dot above when lowercasing capital I's and J's
+	// # whenever there are more accents above.
+	// # (of the accents used in Lithuanian: grave, acute, tilde above, and ogonek)
+	// # 0049; 0069 0307; 0049; 0049; lt More_Above; # LATIN CAPITAL LETTER I
+	// # 004A; 006A 0307; 004A; 004A; lt More_Above; # LATIN CAPITAL LETTER J
+	// # 012E; 012F 0307; 012E; 012E; lt More_Above; # LATIN CAPITAL LETTER I WITH OGONEK
+	// # 00CC; 0069 0307 0300; 00CC; 00CC; lt; # LATIN CAPITAL LETTER I WITH GRAVE
+	// # 00CD; 0069 0307 0301; 00CD; 00CD; lt; # LATIN CAPITAL LETTER I WITH ACUTE
+	// # 0128; 0069 0307 0303; 0128; 0128; lt; # LATIN CAPITAL LETTER I WITH TILDE
+	// ::NFD();
+	// I } [^[:ccc=Not_Reordered:][:ccc=Above:]]* [:ccc=Above:] → i \u0307;
+	// J } [^[:ccc=Not_Reordered:][:ccc=Above:]]* [:ccc=Above:] → j \u0307;
+	// I \u0328 (Į) } [^[:ccc=Not_Reordered:][:ccc=Above:]]* [:ccc=Above:] → i \u0328 \u0307;
+	// I \u0300 (Ì) → i \u0307 \u0300;
+	// I \u0301 (Í) → i \u0307 \u0301;
+	// I \u0303 (Ĩ) → i \u0307 \u0303;
+	// ::Any-Lower();
+	// ::NFC();
+
+	i := 0
+	if r := c.src[c.pSrc]; r < utf8.RuneSelf {
+		lower(c)
+		if r != 'I' && r != 'J' {
+			return true
+		}
+	} else {
+		p := norm.NFD.Properties(c.src[c.pSrc:])
+		if d := p.Decomposition(); len(d) >= 3 && (d[0] == 'I' || d[0] == 'J') {
+			// UTF-8 optimization: the decomposition will only have an above
+			// modifier if the last rune of the decomposition is in [U+300-U+311].
+			// In all other cases, a decomposition starting with I is always
+			// an I followed by modifiers that are not cased themselves. See A.2.
+			if d[1] == 0xCC && d[2] <= 0x91 { // A.2.4.
+				if !c.writeBytes(d[:1]) {
+					return false
+				}
+				c.dst[c.pDst-1] += 'a' - 'A' // lower
+
+				// Assumption: modifier never changes on lowercase. See A.1.
+				// Assumption: all modifiers added have CCC = Above. See A.2.3.
+				return c.writeString("\u0307") && c.writeBytes(d[1:])
+			}
+			// In all other cases the additional modifiers will have a CCC
+			// that is less than 230 (Above). We will insert the U+0307, if
+			// needed, after these modifiers so that a string in FCD form
+			// will remain so. See A.2.2.
+			lower(c)
+			i = 1
+		} else {
+			return lower(c)
+		}
+	}
+
+	for ; i < maxIgnorable && c.next(); i++ {
+		switch c.info.cccType() {
+		case cccZero:
+			c.unreadRune()
+			return true
+		case cccAbove:
+			return c.writeString("\u0307") && c.copy() // See A.1.
+		default:
+			c.copy() // See A.1.
+		}
+	}
+	return i == maxIgnorable
+}
+
+// ltLowerSpan would be the same as isLower.
+
+func ltUpper(f mapFunc) mapFunc {
+	return func(c *context) bool {
+		// Unicode:
+		// 0307; 0307; ; ; lt After_Soft_Dotted; # COMBINING DOT ABOVE
+		//
+		// From CLDR:
+		// # Remove \u0307 following soft-dotteds (i, j, and the like), with possible
+		// # intervening non-230 marks.
+		// ::NFD();
+		// [:Soft_Dotted:] [^[:ccc=Not_Reordered:][:ccc=Above:]]* { \u0307 → ;
+		// ::Any-Upper();
+		// ::NFC();
+
+		// TODO: See A.5. A soft-dotted rune never has an exception. This would
+		// allow us to overload the exception bit and encode this property in
+		// info. Need to measure performance impact of this.
+		r, _ := utf8.DecodeRune(c.src[c.pSrc:])
+		oldPDst := c.pDst
+		if !f(c) {
+			return false
+		}
+		if !unicode.Is(unicode.Soft_Dotted, r) {
+			return true
+		}
+
+		// We don't need to do an NFD normalization, as a soft-dotted rune never
+		// contains U+0307. See A.3.
+
+		i := 0
+		for ; i < maxIgnorable && c.next(); i++ {
+			switch c.info.cccType() {
+			case cccZero:
+				c.unreadRune()
+				return true
+			case cccAbove:
+				if c.hasPrefix("\u0307") {
+					// We don't do a full NFC, but rather combine runes for
+					// some of the common cases. (Returning NFC or
+					// preserving normal form is neither a requirement nor
+					// a possibility anyway).
+					if !c.next() {
+						return false
+					}
+					if c.dst[oldPDst] == 'I' && c.pDst == oldPDst+1 && c.src[c.pSrc] == 0xcc {
+						s := ""
+						switch c.src[c.pSrc+1] {
+						case 0x80: // U+0300 COMBINING GRAVE ACCENT
+							s = "\u00cc" // U+00CC LATIN CAPITAL LETTER I WITH GRAVE
+						case 0x81: // U+0301 COMBINING ACUTE ACCENT
+							s = "\u00cd" // U+00CD LATIN CAPITAL LETTER I WITH ACUTE
+						case 0x83: // U+0303 COMBINING TILDE
+							s = "\u0128" // U+0128 LATIN CAPITAL LETTER I WITH TILDE
+						case 0x88: // U+0308 COMBINING DIAERESIS
+							s = "\u00cf" // U+00CF LATIN CAPITAL LETTER I WITH DIAERESIS
+						default:
+						}
+						if s != "" {
+							c.pDst = oldPDst
+							return c.writeString(s)
+						}
+					}
+				}
+				return c.copy()
+			default:
+				c.copy()
+			}
+		}
+		return i == maxIgnorable
+	}
+}
+
+// TODO: implement ltUpperSpan (low priority: complex and infrequent).
+
+func aztrUpper(f mapFunc) mapFunc {
+	return func(c *context) bool {
+		// i→İ;
+		if c.src[c.pSrc] == 'i' {
+			return c.writeString("İ")
+		}
+		return f(c)
+	}
+}
+
+func aztrLower(c *context) (done bool) {
+	// From CLDR:
+	// # I and i-dotless; I-dot and i are case pairs in Turkish and Azeri
+	// # 0130; 0069; 0130; 0130; tr; # LATIN CAPITAL LETTER I WITH DOT ABOVE
+	// İ→i;
+	// # When lowercasing, remove dot_above in the sequence I + dot_above, which will turn into i.
+	// # This matches the behavior of the canonically equivalent I-dot_above
+	// # 0307; ; 0307; 0307; tr After_I; # COMBINING DOT ABOVE
+	// # When lowercasing, unless an I is before a dot_above, it turns into a dotless i.
+	// # 0049; 0131; 0049; 0049; tr Not_Before_Dot; # LATIN CAPITAL LETTER I
+	// I([^[:ccc=Not_Reordered:][:ccc=Above:]]*)\u0307 → i$1 ;
+	// I→ı ;
+	// ::Any-Lower();
+	if c.hasPrefix("\u0130") { // İ
+		return c.writeString("i")
+	}
+	if c.src[c.pSrc] != 'I' {
+		return lower(c)
+	}
+
+	// We ignore the lower-case I for now, but insert it later when we know
+	// which form we need.
+	start := c.pSrc + c.sz
+
+	i := 0
+Loop:
+	// We check for up to n ignorables before \u0307. As \u0307 is an
+	// ignorable as well, n is maxIgnorable-1.
+	for ; i < maxIgnorable && c.next(); i++ {
+		switch c.info.cccType() {
+		case cccAbove:
+			if c.hasPrefix("\u0307") {
+				return c.writeString("i") && c.writeBytes(c.src[start:c.pSrc]) // ignore U+0307
+			}
+			done = true
+			break Loop
+		case cccZero:
+			c.unreadRune()
+			done = true
+			break Loop
+		default:
+			// We'll write this rune after we know which starter to use.
+		}
+	}
+	if i == maxIgnorable {
+		done = true
+	}
+	return c.writeString("ı") && c.writeBytes(c.src[start:c.pSrc+c.sz]) && done
+}
+
+// aztrLowerSpan would be the same as isLower.
+
+func nlTitle(c *context) bool {
+	// From CLDR:
+	// # Special titlecasing for Dutch initial "ij".
+	// ::Any-Title();
+	// # Fix up Ij at the beginning of a "word" (per Any-Title, notUAX #29)
+	// [:^WB=ALetter:] [:WB=Extend:]* [[:WB=MidLetter:][:WB=MidNumLet:]]? { Ij } → IJ ;
+	if c.src[c.pSrc] != 'I' && c.src[c.pSrc] != 'i' {
+		return title(c)
+	}
+
+	if !c.writeString("I") || !c.next() {
+		return false
+	}
+	if c.src[c.pSrc] == 'j' || c.src[c.pSrc] == 'J' {
+		return c.writeString("J")
+	}
+	c.unreadRune()
+	return true
+}
+
+func nlTitleSpan(c *context) bool {
+	// From CLDR:
+	// # Special titlecasing for Dutch initial "ij".
+	// ::Any-Title();
+	// # Fix up Ij at the beginning of a "word" (per Any-Title, notUAX #29)
+	// [:^WB=ALetter:] [:WB=Extend:]* [[:WB=MidLetter:][:WB=MidNumLet:]]? { Ij } → IJ ;
+	if c.src[c.pSrc] != 'I' {
+		return isTitle(c)
+	}
+	if !c.next() || c.src[c.pSrc] == 'j' {
+		return false
+	}
+	if c.src[c.pSrc] != 'J' {
+		c.unreadRune()
+	}
+	return true
+}
+
+// Not part of CLDR, but see https://unicode.org/cldr/trac/ticket/7078.
+func afnlRewrite(c *context) {
+	if c.hasPrefix("'") || c.hasPrefix("’") {
+		c.isMidWord = true
+	}
+}
diff --git a/vendor/golang.org/x/text/cases/tables15.0.0.go b/vendor/golang.org/x/text/cases/tables15.0.0.go
new file mode 100644
index 00000000000..6aa11161059
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/tables15.0.0.go
@@ -0,0 +1,2527 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+//go:build !go1.27
+
+package cases
+
+// UnicodeVersion is the Unicode version from which the tables in this package are derived.
+const UnicodeVersion = "15.0.0"
+
+var xorData string = "" + // Size: 213 bytes
+	"\x00\x06\x07\x00\x01?\x00\x0f\x03\x00\x0f\x12\x00\x0f\x1f\x00\x0f\x1d" +
+	"\x00\x01\x13\x00\x0f\x16\x00\x0f\x0b\x00\x0f3\x00\x0f7\x00\x01#\x00\x0f?" +
+	"\x00\x0e'\x00\x0f/\x00\x0e>\x00\x0f*\x00\x0c&\x00\x0c*\x00\x0c;\x00\x0c9" +
+	"\x00\x0c%\x00\x01\x08\x00\x03\x0d\x00\x03\x09\x00\x02\x06\x00\x02\x02" +
+	"\x00\x02\x0c\x00\x01\x00\x00\x01\x03\x00\x01\x01\x00\x01 \x00\x01\x0c" +
+	"\x00\x01\x10\x00\x03\x10\x00\x036 \x00\x037 \x00\x0b#\x10\x00\x0b 0\x00" +
+	"\x0b!\x10\x00\x0b!0\x001\x00\x00\x0b(\x04\x00\x03\x04\x1e\x00\x0b)\x08" +
+	"\x00\x03\x0a\x00\x02:\x00\x02>\x00\x02,\x00\x02\x00\x00\x02\x10\x00\x01<" +
+	"\x00\x01&\x00\x01*\x00\x01.\x00\x010\x003 \x00\x01\x18\x00\x01(\x00\x03'" +
+	"\x00\x03)\x00\x03+\x00\x03/\x00\x03\x19\x00\x03\x1b\x00\x03\x1f\x00\x01" +
+	"\x1e\x00\x01\x22"
+
+var exceptions string = "" + // Size: 2450 bytes
+	"\x00\x12\x12μΜΜ\x12\x12ssSSSs\x13\x18i̇i̇\x10\x09II\x13\x1bʼnʼNʼN\x11" +
+	"\x09sSS\x12\x12dždžDž\x12\x12dždžDŽ\x10\x12DŽDž\x12\x12ljljLj\x12\x12ljljLJ\x10\x12LJLj" +
+	"\x12\x12njnjNj\x12\x12njnjNJ\x10\x12NJNj\x13\x1bǰJ̌J̌\x12\x12dzdzDz\x12\x12dzdzDZ\x10" +
+	"\x12DZDz\x13\x18ⱥⱥ\x13\x18ⱦⱦ\x10\x1bⱾⱾ\x10\x1bⱿⱿ\x10\x1bⱯⱯ\x10\x1bⱭⱭ\x10" +
+	"\x1bⱰⱰ\x10\x1bꞫꞫ\x10\x1bꞬꞬ\x10\x1bꞍꞍ\x10\x1bꞪꞪ\x10\x1bꞮꞮ\x10\x1bⱢⱢ\x10" +
+	"\x1bꞭꞭ\x10\x1bⱮⱮ\x10\x1bⱤⱤ\x10\x1bꟅꟅ\x10\x1bꞱꞱ\x10\x1bꞲꞲ\x10\x1bꞰꞰ2\x12ι" +
+	"ΙΙ\x166ΐΪ́Ϊ́\x166ΰΫ́Ϋ́\x12\x12σΣΣ\x12\x12βΒΒ\x12\x12θΘΘ\x12\x12" +
+	"φΦΦ\x12\x12πΠΠ\x12\x12κΚΚ\x12\x12ρΡΡ\x12\x12εΕΕ\x14$եւԵՒԵւ\x10\x1bᲐა" +
+	"\x10\x1bᲑბ\x10\x1bᲒგ\x10\x1bᲓდ\x10\x1bᲔე\x10\x1bᲕვ\x10\x1bᲖზ\x10\x1bᲗთ" +
+	"\x10\x1bᲘი\x10\x1bᲙკ\x10\x1bᲚლ\x10\x1bᲛმ\x10\x1bᲜნ\x10\x1bᲝო\x10\x1bᲞპ" +
+	"\x10\x1bᲟჟ\x10\x1bᲠრ\x10\x1bᲡს\x10\x1bᲢტ\x10\x1bᲣუ\x10\x1bᲤფ\x10\x1bᲥქ" +
+	"\x10\x1bᲦღ\x10\x1bᲧყ\x10\x1bᲨშ\x10\x1bᲩჩ\x10\x1bᲪც\x10\x1bᲫძ\x10\x1bᲬწ" +
+	"\x10\x1bᲭჭ\x10\x1bᲮხ\x10\x1bᲯჯ\x10\x1bᲰჰ\x10\x1bᲱჱ\x10\x1bᲲჲ\x10\x1bᲳჳ" +
+	"\x10\x1bᲴჴ\x10\x1bᲵჵ\x10\x1bᲶჶ\x10\x1bᲷჷ\x10\x1bᲸჸ\x10\x1bᲹჹ\x10\x1bᲺჺ" +
+	"\x10\x1bᲽჽ\x10\x1bᲾჾ\x10\x1bᲿჿ\x12\x12вВВ\x12\x12дДД\x12\x12оОО\x12\x12с" +
+	"СС\x12\x12тТТ\x12\x12тТТ\x12\x12ъЪЪ\x12\x12ѣѢѢ\x13\x1bꙋꙊꙊ\x13\x1bẖH̱H̱" +
+	"\x13\x1bẗT̈T̈\x13\x1bẘW̊W̊\x13\x1bẙY̊Y̊\x13\x1baʾAʾAʾ\x13\x1bṡṠṠ\x12" +
+	"\x10ssß\x14$ὐΥ̓Υ̓\x166ὒΥ̓̀Υ̓̀\x166ὔΥ̓́Υ̓́\x166ὖΥ̓͂Υ̓͂\x15+ἀιἈΙᾈ" +
+	"\x15+ἁιἉΙᾉ\x15+ἂιἊΙᾊ\x15+ἃιἋΙᾋ\x15+ἄιἌΙᾌ\x15+ἅιἍΙᾍ\x15+ἆιἎΙᾎ\x15+ἇιἏΙᾏ" +
+	"\x15\x1dἀιᾀἈΙ\x15\x1dἁιᾁἉΙ\x15\x1dἂιᾂἊΙ\x15\x1dἃιᾃἋΙ\x15\x1dἄιᾄἌΙ\x15" +
+	"\x1dἅιᾅἍΙ\x15\x1dἆιᾆἎΙ\x15\x1dἇιᾇἏΙ\x15+ἠιἨΙᾘ\x15+ἡιἩΙᾙ\x15+ἢιἪΙᾚ\x15+ἣι" +
+	"ἫΙᾛ\x15+ἤιἬΙᾜ\x15+ἥιἭΙᾝ\x15+ἦιἮΙᾞ\x15+ἧιἯΙᾟ\x15\x1dἠιᾐἨΙ\x15\x1dἡιᾑἩΙ" +
+	"\x15\x1dἢιᾒἪΙ\x15\x1dἣιᾓἫΙ\x15\x1dἤιᾔἬΙ\x15\x1dἥιᾕἭΙ\x15\x1dἦιᾖἮΙ\x15" +
+	"\x1dἧιᾗἯΙ\x15+ὠιὨΙᾨ\x15+ὡιὩΙᾩ\x15+ὢιὪΙᾪ\x15+ὣιὫΙᾫ\x15+ὤιὬΙᾬ\x15+ὥιὭΙᾭ" +
+	"\x15+ὦιὮΙᾮ\x15+ὧιὯΙᾯ\x15\x1dὠιᾠὨΙ\x15\x1dὡιᾡὩΙ\x15\x1dὢιᾢὪΙ\x15\x1dὣιᾣὫΙ" +
+	"\x15\x1dὤιᾤὬΙ\x15\x1dὥιᾥὭΙ\x15\x1dὦιᾦὮΙ\x15\x1dὧιᾧὯΙ\x15-ὰιᾺΙᾺͅ\x14#αιΑΙ" +
+	"ᾼ\x14$άιΆΙΆͅ\x14$ᾶΑ͂Α͂\x166ᾶιΑ͂Ιᾼ͂\x14\x1cαιᾳΑΙ\x12\x12ιΙΙ\x15-ὴιῊΙ" +
+	"Ὴͅ\x14#ηιΗΙῌ\x14$ήιΉΙΉͅ\x14$ῆΗ͂Η͂\x166ῆιΗ͂Ιῌ͂\x14\x1cηιῃΗΙ\x166ῒΙ" +
+	"̈̀Ϊ̀\x166ΐΪ́Ϊ́\x14$ῖΙ͂Ι͂\x166ῗΪ͂Ϊ͂\x166ῢΫ̀Ϋ̀\x166ΰΫ́Ϋ" +
+	"́\x14$ῤΡ̓Ρ̓\x14$ῦΥ͂Υ͂\x166ῧΫ͂Ϋ͂\x15-ὼιῺΙῺͅ\x14#ωιΩΙῼ\x14$ώιΏΙΏͅ" +
+	"\x14$ῶΩ͂Ω͂\x166ῶιΩ͂Ιῼ͂\x14\x1cωιῳΩΙ\x12\x10ωω\x11\x08kk\x12\x10åå\x12" +
+	"\x10ɫɫ\x12\x10ɽɽ\x10\x12ȺȺ\x10\x12ȾȾ\x12\x10ɑɑ\x12\x10ɱɱ\x12\x10ɐɐ\x12" +
+	"\x10ɒɒ\x12\x10ȿȿ\x12\x10ɀɀ\x12\x10ɥɥ\x12\x10ɦɦ\x12\x10ɜɜ\x12\x10ɡɡ\x12" +
+	"\x10ɬɬ\x12\x10ɪɪ\x12\x10ʞʞ\x12\x10ʇʇ\x12\x10ʝʝ\x12\x10ʂʂ\x12\x12ffFFFf" +
+	"\x12\x12fiFIFi\x12\x12flFLFl\x13\x1bffiFFIFfi\x13\x1bfflFFLFfl\x12\x12st" +
+	"STSt\x12\x12stSTSt\x14$մնՄՆՄն\x14$մեՄԵՄե\x14$միՄԻՄի\x14$վնՎՆՎն\x14$մխՄԽՄ" +
+	"խ"
+
+// 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 *caseTrie) lookup(s []byte) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return caseValues[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 := caseIndex[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 := caseIndex[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 = caseIndex[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 := caseIndex[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 = caseIndex[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 = caseIndex[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 *caseTrie) lookupUnsafe(s []byte) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return caseValues[c0]
+	}
+	i := caseIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = caseIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = caseIndex[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 *caseTrie) lookupString(s string) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return caseValues[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 := caseIndex[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 := caseIndex[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 = caseIndex[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 := caseIndex[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 = caseIndex[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 = caseIndex[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 *caseTrie) lookupStringUnsafe(s string) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return caseValues[c0]
+	}
+	i := caseIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = caseIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = caseIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// caseTrie. Total size: 13398 bytes (13.08 KiB). Checksum: 544af6e6b1b70931.
+type caseTrie struct{}
+
+func newCaseTrie(i int) *caseTrie {
+	return &caseTrie{}
+}
+
+// lookupValue determines the type of block n and looks up the value for b.
+func (t *caseTrie) lookupValue(n uint32, b byte) uint16 {
+	switch {
+	case n < 22:
+		return uint16(caseValues[n<<6+uint32(b)])
+	default:
+		n -= 22
+		return uint16(sparse.lookup(n, b))
+	}
+}
+
+// caseValues: 24 blocks, 1536 entries, 3072 bytes
+// The third block is the zero block.
+var caseValues = [1536]uint16{
+	// Block 0x0, offset 0x0
+	0x27: 0x0054,
+	0x2e: 0x0054,
+	0x30: 0x0010, 0x31: 0x0010, 0x32: 0x0010, 0x33: 0x0010, 0x34: 0x0010, 0x35: 0x0010,
+	0x36: 0x0010, 0x37: 0x0010, 0x38: 0x0010, 0x39: 0x0010, 0x3a: 0x0054,
+	// Block 0x1, offset 0x40
+	0x41: 0x2013, 0x42: 0x2013, 0x43: 0x2013, 0x44: 0x2013, 0x45: 0x2013,
+	0x46: 0x2013, 0x47: 0x2013, 0x48: 0x2013, 0x49: 0x2013, 0x4a: 0x2013, 0x4b: 0x2013,
+	0x4c: 0x2013, 0x4d: 0x2013, 0x4e: 0x2013, 0x4f: 0x2013, 0x50: 0x2013, 0x51: 0x2013,
+	0x52: 0x2013, 0x53: 0x2013, 0x54: 0x2013, 0x55: 0x2013, 0x56: 0x2013, 0x57: 0x2013,
+	0x58: 0x2013, 0x59: 0x2013, 0x5a: 0x2013,
+	0x5e: 0x0004, 0x5f: 0x0010, 0x60: 0x0004, 0x61: 0x2012, 0x62: 0x2012, 0x63: 0x2012,
+	0x64: 0x2012, 0x65: 0x2012, 0x66: 0x2012, 0x67: 0x2012, 0x68: 0x2012, 0x69: 0x2012,
+	0x6a: 0x2012, 0x6b: 0x2012, 0x6c: 0x2012, 0x6d: 0x2012, 0x6e: 0x2012, 0x6f: 0x2012,
+	0x70: 0x2012, 0x71: 0x2012, 0x72: 0x2012, 0x73: 0x2012, 0x74: 0x2012, 0x75: 0x2012,
+	0x76: 0x2012, 0x77: 0x2012, 0x78: 0x2012, 0x79: 0x2012, 0x7a: 0x2012,
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc0: 0x0852, 0xc1: 0x0b53, 0xc2: 0x0113, 0xc3: 0x0112, 0xc4: 0x0113, 0xc5: 0x0112,
+	0xc6: 0x0b53, 0xc7: 0x0f13, 0xc8: 0x0f12, 0xc9: 0x0e53, 0xca: 0x1153, 0xcb: 0x0713,
+	0xcc: 0x0712, 0xcd: 0x0012, 0xce: 0x1453, 0xcf: 0x1753, 0xd0: 0x1a53, 0xd1: 0x0313,
+	0xd2: 0x0312, 0xd3: 0x1d53, 0xd4: 0x2053, 0xd5: 0x2352, 0xd6: 0x2653, 0xd7: 0x2653,
+	0xd8: 0x0113, 0xd9: 0x0112, 0xda: 0x2952, 0xdb: 0x0012, 0xdc: 0x1d53, 0xdd: 0x2c53,
+	0xde: 0x2f52, 0xdf: 0x3253, 0xe0: 0x0113, 0xe1: 0x0112, 0xe2: 0x0113, 0xe3: 0x0112,
+	0xe4: 0x0113, 0xe5: 0x0112, 0xe6: 0x3553, 0xe7: 0x0f13, 0xe8: 0x0f12, 0xe9: 0x3853,
+	0xea: 0x0012, 0xeb: 0x0012, 0xec: 0x0113, 0xed: 0x0112, 0xee: 0x3553, 0xef: 0x1f13,
+	0xf0: 0x1f12, 0xf1: 0x3b53, 0xf2: 0x3e53, 0xf3: 0x0713, 0xf4: 0x0712, 0xf5: 0x0313,
+	0xf6: 0x0312, 0xf7: 0x4153, 0xf8: 0x0113, 0xf9: 0x0112, 0xfa: 0x0012, 0xfb: 0x0010,
+	0xfc: 0x0113, 0xfd: 0x0112, 0xfe: 0x0012, 0xff: 0x4452,
+	// Block 0x4, offset 0x100
+	0x100: 0x0010, 0x101: 0x0010, 0x102: 0x0010, 0x103: 0x0010, 0x104: 0x02db, 0x105: 0x0359,
+	0x106: 0x03da, 0x107: 0x043b, 0x108: 0x04b9, 0x109: 0x053a, 0x10a: 0x059b, 0x10b: 0x0619,
+	0x10c: 0x069a, 0x10d: 0x0313, 0x10e: 0x0312, 0x10f: 0x1f13, 0x110: 0x1f12, 0x111: 0x0313,
+	0x112: 0x0312, 0x113: 0x0713, 0x114: 0x0712, 0x115: 0x0313, 0x116: 0x0312, 0x117: 0x0f13,
+	0x118: 0x0f12, 0x119: 0x0313, 0x11a: 0x0312, 0x11b: 0x0713, 0x11c: 0x0712, 0x11d: 0x1452,
+	0x11e: 0x0113, 0x11f: 0x0112, 0x120: 0x0113, 0x121: 0x0112, 0x122: 0x0113, 0x123: 0x0112,
+	0x124: 0x0113, 0x125: 0x0112, 0x126: 0x0113, 0x127: 0x0112, 0x128: 0x0113, 0x129: 0x0112,
+	0x12a: 0x0113, 0x12b: 0x0112, 0x12c: 0x0113, 0x12d: 0x0112, 0x12e: 0x0113, 0x12f: 0x0112,
+	0x130: 0x06fa, 0x131: 0x07ab, 0x132: 0x0829, 0x133: 0x08aa, 0x134: 0x0113, 0x135: 0x0112,
+	0x136: 0x2353, 0x137: 0x4453, 0x138: 0x0113, 0x139: 0x0112, 0x13a: 0x0113, 0x13b: 0x0112,
+	0x13c: 0x0113, 0x13d: 0x0112, 0x13e: 0x0113, 0x13f: 0x0112,
+	// Block 0x5, offset 0x140
+	0x140: 0x0a8a, 0x141: 0x0313, 0x142: 0x0312, 0x143: 0x0853, 0x144: 0x4753, 0x145: 0x4a53,
+	0x146: 0x0113, 0x147: 0x0112, 0x148: 0x0113, 0x149: 0x0112, 0x14a: 0x0113, 0x14b: 0x0112,
+	0x14c: 0x0113, 0x14d: 0x0112, 0x14e: 0x0113, 0x14f: 0x0112, 0x150: 0x0b0a, 0x151: 0x0b8a,
+	0x152: 0x0c0a, 0x153: 0x0b52, 0x154: 0x0b52, 0x155: 0x0012, 0x156: 0x0e52, 0x157: 0x1152,
+	0x158: 0x0012, 0x159: 0x1752, 0x15a: 0x0012, 0x15b: 0x1a52, 0x15c: 0x0c8a, 0x15d: 0x0012,
+	0x15e: 0x0012, 0x15f: 0x0012, 0x160: 0x1d52, 0x161: 0x0d0a, 0x162: 0x0012, 0x163: 0x2052,
+	0x164: 0x0012, 0x165: 0x0d8a, 0x166: 0x0e0a, 0x167: 0x0012, 0x168: 0x2652, 0x169: 0x2652,
+	0x16a: 0x0e8a, 0x16b: 0x0f0a, 0x16c: 0x0f8a, 0x16d: 0x0012, 0x16e: 0x0012, 0x16f: 0x1d52,
+	0x170: 0x0012, 0x171: 0x100a, 0x172: 0x2c52, 0x173: 0x0012, 0x174: 0x0012, 0x175: 0x3252,
+	0x176: 0x0012, 0x177: 0x0012, 0x178: 0x0012, 0x179: 0x0012, 0x17a: 0x0012, 0x17b: 0x0012,
+	0x17c: 0x0012, 0x17d: 0x108a, 0x17e: 0x0012, 0x17f: 0x0012,
+	// Block 0x6, offset 0x180
+	0x180: 0x3552, 0x181: 0x0012, 0x182: 0x110a, 0x183: 0x3852, 0x184: 0x0012, 0x185: 0x0012,
+	0x186: 0x0012, 0x187: 0x118a, 0x188: 0x3552, 0x189: 0x4752, 0x18a: 0x3b52, 0x18b: 0x3e52,
+	0x18c: 0x4a52, 0x18d: 0x0012, 0x18e: 0x0012, 0x18f: 0x0012, 0x190: 0x0012, 0x191: 0x0012,
+	0x192: 0x4152, 0x193: 0x0012, 0x194: 0x0010, 0x195: 0x0012, 0x196: 0x0012, 0x197: 0x0012,
+	0x198: 0x0012, 0x199: 0x0012, 0x19a: 0x0012, 0x19b: 0x0012, 0x19c: 0x0012, 0x19d: 0x120a,
+	0x19e: 0x128a, 0x19f: 0x0012, 0x1a0: 0x0012, 0x1a1: 0x0012, 0x1a2: 0x0012, 0x1a3: 0x0012,
+	0x1a4: 0x0012, 0x1a5: 0x0012, 0x1a6: 0x0012, 0x1a7: 0x0012, 0x1a8: 0x0012, 0x1a9: 0x0012,
+	0x1aa: 0x0012, 0x1ab: 0x0012, 0x1ac: 0x0012, 0x1ad: 0x0012, 0x1ae: 0x0012, 0x1af: 0x0012,
+	0x1b0: 0x0015, 0x1b1: 0x0015, 0x1b2: 0x0015, 0x1b3: 0x0015, 0x1b4: 0x0015, 0x1b5: 0x0015,
+	0x1b6: 0x0015, 0x1b7: 0x0015, 0x1b8: 0x0015, 0x1b9: 0x0014, 0x1ba: 0x0014, 0x1bb: 0x0014,
+	0x1bc: 0x0014, 0x1bd: 0x0014, 0x1be: 0x0014, 0x1bf: 0x0014,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x0024, 0x1c1: 0x0024, 0x1c2: 0x0024, 0x1c3: 0x0024, 0x1c4: 0x0024, 0x1c5: 0x130d,
+	0x1c6: 0x0024, 0x1c7: 0x0034, 0x1c8: 0x0034, 0x1c9: 0x0034, 0x1ca: 0x0024, 0x1cb: 0x0024,
+	0x1cc: 0x0024, 0x1cd: 0x0034, 0x1ce: 0x0034, 0x1cf: 0x0014, 0x1d0: 0x0024, 0x1d1: 0x0024,
+	0x1d2: 0x0024, 0x1d3: 0x0034, 0x1d4: 0x0034, 0x1d5: 0x0034, 0x1d6: 0x0034, 0x1d7: 0x0024,
+	0x1d8: 0x0034, 0x1d9: 0x0034, 0x1da: 0x0034, 0x1db: 0x0024, 0x1dc: 0x0034, 0x1dd: 0x0034,
+	0x1de: 0x0034, 0x1df: 0x0034, 0x1e0: 0x0034, 0x1e1: 0x0034, 0x1e2: 0x0034, 0x1e3: 0x0024,
+	0x1e4: 0x0024, 0x1e5: 0x0024, 0x1e6: 0x0024, 0x1e7: 0x0024, 0x1e8: 0x0024, 0x1e9: 0x0024,
+	0x1ea: 0x0024, 0x1eb: 0x0024, 0x1ec: 0x0024, 0x1ed: 0x0024, 0x1ee: 0x0024, 0x1ef: 0x0024,
+	0x1f0: 0x0113, 0x1f1: 0x0112, 0x1f2: 0x0113, 0x1f3: 0x0112, 0x1f4: 0x0014, 0x1f5: 0x0004,
+	0x1f6: 0x0113, 0x1f7: 0x0112, 0x1fa: 0x0015, 0x1fb: 0x4d52,
+	0x1fc: 0x5052, 0x1fd: 0x5052, 0x1ff: 0x5353,
+	// Block 0x8, offset 0x200
+	0x204: 0x0004, 0x205: 0x0004,
+	0x206: 0x2a13, 0x207: 0x0054, 0x208: 0x2513, 0x209: 0x2713, 0x20a: 0x2513,
+	0x20c: 0x5653, 0x20e: 0x5953, 0x20f: 0x5c53, 0x210: 0x138a, 0x211: 0x2013,
+	0x212: 0x2013, 0x213: 0x2013, 0x214: 0x2013, 0x215: 0x2013, 0x216: 0x2013, 0x217: 0x2013,
+	0x218: 0x2013, 0x219: 0x2013, 0x21a: 0x2013, 0x21b: 0x2013, 0x21c: 0x2013, 0x21d: 0x2013,
+	0x21e: 0x2013, 0x21f: 0x2013, 0x220: 0x5f53, 0x221: 0x5f53, 0x223: 0x5f53,
+	0x224: 0x5f53, 0x225: 0x5f53, 0x226: 0x5f53, 0x227: 0x5f53, 0x228: 0x5f53, 0x229: 0x5f53,
+	0x22a: 0x5f53, 0x22b: 0x5f53, 0x22c: 0x2a12, 0x22d: 0x2512, 0x22e: 0x2712, 0x22f: 0x2512,
+	0x230: 0x14ca, 0x231: 0x2012, 0x232: 0x2012, 0x233: 0x2012, 0x234: 0x2012, 0x235: 0x2012,
+	0x236: 0x2012, 0x237: 0x2012, 0x238: 0x2012, 0x239: 0x2012, 0x23a: 0x2012, 0x23b: 0x2012,
+	0x23c: 0x2012, 0x23d: 0x2012, 0x23e: 0x2012, 0x23f: 0x2012,
+	// Block 0x9, offset 0x240
+	0x240: 0x5f52, 0x241: 0x5f52, 0x242: 0x160a, 0x243: 0x5f52, 0x244: 0x5f52, 0x245: 0x5f52,
+	0x246: 0x5f52, 0x247: 0x5f52, 0x248: 0x5f52, 0x249: 0x5f52, 0x24a: 0x5f52, 0x24b: 0x5f52,
+	0x24c: 0x5652, 0x24d: 0x5952, 0x24e: 0x5c52, 0x24f: 0x1813, 0x250: 0x168a, 0x251: 0x170a,
+	0x252: 0x0013, 0x253: 0x0013, 0x254: 0x0013, 0x255: 0x178a, 0x256: 0x180a, 0x257: 0x1812,
+	0x258: 0x0113, 0x259: 0x0112, 0x25a: 0x0113, 0x25b: 0x0112, 0x25c: 0x0113, 0x25d: 0x0112,
+	0x25e: 0x0113, 0x25f: 0x0112, 0x260: 0x0113, 0x261: 0x0112, 0x262: 0x0113, 0x263: 0x0112,
+	0x264: 0x0113, 0x265: 0x0112, 0x266: 0x0113, 0x267: 0x0112, 0x268: 0x0113, 0x269: 0x0112,
+	0x26a: 0x0113, 0x26b: 0x0112, 0x26c: 0x0113, 0x26d: 0x0112, 0x26e: 0x0113, 0x26f: 0x0112,
+	0x270: 0x188a, 0x271: 0x190a, 0x272: 0x0b12, 0x273: 0x5352, 0x274: 0x6253, 0x275: 0x198a,
+	0x277: 0x0f13, 0x278: 0x0f12, 0x279: 0x0b13, 0x27a: 0x0113, 0x27b: 0x0112,
+	0x27c: 0x0012, 0x27d: 0x4d53, 0x27e: 0x5053, 0x27f: 0x5053,
+	// Block 0xa, offset 0x280
+	0x280: 0x6852, 0x281: 0x6852, 0x282: 0x6852, 0x283: 0x6852, 0x284: 0x6852, 0x285: 0x6852,
+	0x286: 0x6852, 0x287: 0x1a0a, 0x288: 0x0012, 0x28a: 0x0010,
+	0x291: 0x0034,
+	0x292: 0x0024, 0x293: 0x0024, 0x294: 0x0024, 0x295: 0x0024, 0x296: 0x0034, 0x297: 0x0024,
+	0x298: 0x0024, 0x299: 0x0024, 0x29a: 0x0034, 0x29b: 0x0034, 0x29c: 0x0024, 0x29d: 0x0024,
+	0x29e: 0x0024, 0x29f: 0x0024, 0x2a0: 0x0024, 0x2a1: 0x0024, 0x2a2: 0x0034, 0x2a3: 0x0034,
+	0x2a4: 0x0034, 0x2a5: 0x0034, 0x2a6: 0x0034, 0x2a7: 0x0034, 0x2a8: 0x0024, 0x2a9: 0x0024,
+	0x2aa: 0x0034, 0x2ab: 0x0024, 0x2ac: 0x0024, 0x2ad: 0x0034, 0x2ae: 0x0034, 0x2af: 0x0024,
+	0x2b0: 0x0034, 0x2b1: 0x0034, 0x2b2: 0x0034, 0x2b3: 0x0034, 0x2b4: 0x0034, 0x2b5: 0x0034,
+	0x2b6: 0x0034, 0x2b7: 0x0034, 0x2b8: 0x0034, 0x2b9: 0x0034, 0x2ba: 0x0034, 0x2bb: 0x0034,
+	0x2bc: 0x0034, 0x2bd: 0x0034, 0x2bf: 0x0034,
+	// Block 0xb, offset 0x2c0
+	0x2c0: 0x0010, 0x2c1: 0x0010, 0x2c2: 0x0010, 0x2c3: 0x0010, 0x2c4: 0x0010, 0x2c5: 0x0010,
+	0x2c6: 0x0010, 0x2c7: 0x0010, 0x2c8: 0x0010, 0x2c9: 0x0014, 0x2ca: 0x0024, 0x2cb: 0x0024,
+	0x2cc: 0x0024, 0x2cd: 0x0024, 0x2ce: 0x0024, 0x2cf: 0x0034, 0x2d0: 0x0034, 0x2d1: 0x0034,
+	0x2d2: 0x0034, 0x2d3: 0x0034, 0x2d4: 0x0024, 0x2d5: 0x0024, 0x2d6: 0x0024, 0x2d7: 0x0024,
+	0x2d8: 0x0024, 0x2d9: 0x0024, 0x2da: 0x0024, 0x2db: 0x0024, 0x2dc: 0x0024, 0x2dd: 0x0024,
+	0x2de: 0x0024, 0x2df: 0x0024, 0x2e0: 0x0024, 0x2e1: 0x0024, 0x2e2: 0x0014, 0x2e3: 0x0034,
+	0x2e4: 0x0024, 0x2e5: 0x0024, 0x2e6: 0x0034, 0x2e7: 0x0024, 0x2e8: 0x0024, 0x2e9: 0x0034,
+	0x2ea: 0x0024, 0x2eb: 0x0024, 0x2ec: 0x0024, 0x2ed: 0x0034, 0x2ee: 0x0034, 0x2ef: 0x0034,
+	0x2f0: 0x0034, 0x2f1: 0x0034, 0x2f2: 0x0034, 0x2f3: 0x0024, 0x2f4: 0x0024, 0x2f5: 0x0024,
+	0x2f6: 0x0034, 0x2f7: 0x0024, 0x2f8: 0x0024, 0x2f9: 0x0034, 0x2fa: 0x0034, 0x2fb: 0x0024,
+	0x2fc: 0x0024, 0x2fd: 0x0024, 0x2fe: 0x0024, 0x2ff: 0x0024,
+	// Block 0xc, offset 0x300
+	0x300: 0x7053, 0x301: 0x7053, 0x302: 0x7053, 0x303: 0x7053, 0x304: 0x7053, 0x305: 0x7053,
+	0x307: 0x7053,
+	0x30d: 0x7053, 0x310: 0x1aea, 0x311: 0x1b6a,
+	0x312: 0x1bea, 0x313: 0x1c6a, 0x314: 0x1cea, 0x315: 0x1d6a, 0x316: 0x1dea, 0x317: 0x1e6a,
+	0x318: 0x1eea, 0x319: 0x1f6a, 0x31a: 0x1fea, 0x31b: 0x206a, 0x31c: 0x20ea, 0x31d: 0x216a,
+	0x31e: 0x21ea, 0x31f: 0x226a, 0x320: 0x22ea, 0x321: 0x236a, 0x322: 0x23ea, 0x323: 0x246a,
+	0x324: 0x24ea, 0x325: 0x256a, 0x326: 0x25ea, 0x327: 0x266a, 0x328: 0x26ea, 0x329: 0x276a,
+	0x32a: 0x27ea, 0x32b: 0x286a, 0x32c: 0x28ea, 0x32d: 0x296a, 0x32e: 0x29ea, 0x32f: 0x2a6a,
+	0x330: 0x2aea, 0x331: 0x2b6a, 0x332: 0x2bea, 0x333: 0x2c6a, 0x334: 0x2cea, 0x335: 0x2d6a,
+	0x336: 0x2dea, 0x337: 0x2e6a, 0x338: 0x2eea, 0x339: 0x2f6a, 0x33a: 0x2fea,
+	0x33c: 0x0015, 0x33d: 0x306a, 0x33e: 0x30ea, 0x33f: 0x316a,
+	// Block 0xd, offset 0x340
+	0x340: 0x0812, 0x341: 0x0812, 0x342: 0x0812, 0x343: 0x0812, 0x344: 0x0812, 0x345: 0x0812,
+	0x348: 0x0813, 0x349: 0x0813, 0x34a: 0x0813, 0x34b: 0x0813,
+	0x34c: 0x0813, 0x34d: 0x0813, 0x350: 0x3b1a, 0x351: 0x0812,
+	0x352: 0x3bfa, 0x353: 0x0812, 0x354: 0x3d3a, 0x355: 0x0812, 0x356: 0x3e7a, 0x357: 0x0812,
+	0x359: 0x0813, 0x35b: 0x0813, 0x35d: 0x0813,
+	0x35f: 0x0813, 0x360: 0x0812, 0x361: 0x0812, 0x362: 0x0812, 0x363: 0x0812,
+	0x364: 0x0812, 0x365: 0x0812, 0x366: 0x0812, 0x367: 0x0812, 0x368: 0x0813, 0x369: 0x0813,
+	0x36a: 0x0813, 0x36b: 0x0813, 0x36c: 0x0813, 0x36d: 0x0813, 0x36e: 0x0813, 0x36f: 0x0813,
+	0x370: 0x9252, 0x371: 0x9252, 0x372: 0x9552, 0x373: 0x9552, 0x374: 0x9852, 0x375: 0x9852,
+	0x376: 0x9b52, 0x377: 0x9b52, 0x378: 0x9e52, 0x379: 0x9e52, 0x37a: 0xa152, 0x37b: 0xa152,
+	0x37c: 0x4d52, 0x37d: 0x4d52,
+	// Block 0xe, offset 0x380
+	0x380: 0x3fba, 0x381: 0x40aa, 0x382: 0x419a, 0x383: 0x428a, 0x384: 0x437a, 0x385: 0x446a,
+	0x386: 0x455a, 0x387: 0x464a, 0x388: 0x4739, 0x389: 0x4829, 0x38a: 0x4919, 0x38b: 0x4a09,
+	0x38c: 0x4af9, 0x38d: 0x4be9, 0x38e: 0x4cd9, 0x38f: 0x4dc9, 0x390: 0x4eba, 0x391: 0x4faa,
+	0x392: 0x509a, 0x393: 0x518a, 0x394: 0x527a, 0x395: 0x536a, 0x396: 0x545a, 0x397: 0x554a,
+	0x398: 0x5639, 0x399: 0x5729, 0x39a: 0x5819, 0x39b: 0x5909, 0x39c: 0x59f9, 0x39d: 0x5ae9,
+	0x39e: 0x5bd9, 0x39f: 0x5cc9, 0x3a0: 0x5dba, 0x3a1: 0x5eaa, 0x3a2: 0x5f9a, 0x3a3: 0x608a,
+	0x3a4: 0x617a, 0x3a5: 0x626a, 0x3a6: 0x635a, 0x3a7: 0x644a, 0x3a8: 0x6539, 0x3a9: 0x6629,
+	0x3aa: 0x6719, 0x3ab: 0x6809, 0x3ac: 0x68f9, 0x3ad: 0x69e9, 0x3ae: 0x6ad9, 0x3af: 0x6bc9,
+	0x3b0: 0x0812, 0x3b1: 0x0812, 0x3b2: 0x6cba, 0x3b3: 0x6dca, 0x3b4: 0x6e9a,
+	0x3b6: 0x6f7a, 0x3b7: 0x705a, 0x3b8: 0x0813, 0x3b9: 0x0813, 0x3ba: 0x9253, 0x3bb: 0x9253,
+	0x3bc: 0x7199, 0x3bd: 0x0004, 0x3be: 0x726a, 0x3bf: 0x0004,
+	// Block 0xf, offset 0x3c0
+	0x3c0: 0x0004, 0x3c1: 0x0004, 0x3c2: 0x72ea, 0x3c3: 0x73fa, 0x3c4: 0x74ca,
+	0x3c6: 0x75aa, 0x3c7: 0x768a, 0x3c8: 0x9553, 0x3c9: 0x9553, 0x3ca: 0x9853, 0x3cb: 0x9853,
+	0x3cc: 0x77c9, 0x3cd: 0x0004, 0x3ce: 0x0004, 0x3cf: 0x0004, 0x3d0: 0x0812, 0x3d1: 0x0812,
+	0x3d2: 0x789a, 0x3d3: 0x79da, 0x3d6: 0x7b1a, 0x3d7: 0x7bfa,
+	0x3d8: 0x0813, 0x3d9: 0x0813, 0x3da: 0x9b53, 0x3db: 0x9b53, 0x3dd: 0x0004,
+	0x3de: 0x0004, 0x3df: 0x0004, 0x3e0: 0x0812, 0x3e1: 0x0812, 0x3e2: 0x7d3a, 0x3e3: 0x7e7a,
+	0x3e4: 0x7fba, 0x3e5: 0x0912, 0x3e6: 0x809a, 0x3e7: 0x817a, 0x3e8: 0x0813, 0x3e9: 0x0813,
+	0x3ea: 0xa153, 0x3eb: 0xa153, 0x3ec: 0x0913, 0x3ed: 0x0004, 0x3ee: 0x0004, 0x3ef: 0x0004,
+	0x3f2: 0x82ba, 0x3f3: 0x83ca, 0x3f4: 0x849a,
+	0x3f6: 0x857a, 0x3f7: 0x865a, 0x3f8: 0x9e53, 0x3f9: 0x9e53, 0x3fa: 0x4d53, 0x3fb: 0x4d53,
+	0x3fc: 0x8799, 0x3fd: 0x0004, 0x3fe: 0x0004,
+	// Block 0x10, offset 0x400
+	0x402: 0x0013,
+	0x407: 0x0013, 0x40a: 0x0012, 0x40b: 0x0013,
+	0x40c: 0x0013, 0x40d: 0x0013, 0x40e: 0x0012, 0x40f: 0x0012, 0x410: 0x0013, 0x411: 0x0013,
+	0x412: 0x0013, 0x413: 0x0012, 0x415: 0x0013,
+	0x419: 0x0013, 0x41a: 0x0013, 0x41b: 0x0013, 0x41c: 0x0013, 0x41d: 0x0013,
+	0x424: 0x0013, 0x426: 0x886b, 0x428: 0x0013,
+	0x42a: 0x88cb, 0x42b: 0x890b, 0x42c: 0x0013, 0x42d: 0x0013, 0x42f: 0x0012,
+	0x430: 0x0013, 0x431: 0x0013, 0x432: 0xa453, 0x433: 0x0013, 0x434: 0x0012, 0x435: 0x0010,
+	0x436: 0x0010, 0x437: 0x0010, 0x438: 0x0010, 0x439: 0x0012,
+	0x43c: 0x0012, 0x43d: 0x0012, 0x43e: 0x0013, 0x43f: 0x0013,
+	// Block 0x11, offset 0x440
+	0x440: 0x1a13, 0x441: 0x1a13, 0x442: 0x1e13, 0x443: 0x1e13, 0x444: 0x1a13, 0x445: 0x1a13,
+	0x446: 0x2613, 0x447: 0x2613, 0x448: 0x2a13, 0x449: 0x2a13, 0x44a: 0x2e13, 0x44b: 0x2e13,
+	0x44c: 0x2a13, 0x44d: 0x2a13, 0x44e: 0x2613, 0x44f: 0x2613, 0x450: 0xa752, 0x451: 0xa752,
+	0x452: 0xaa52, 0x453: 0xaa52, 0x454: 0xad52, 0x455: 0xad52, 0x456: 0xaa52, 0x457: 0xaa52,
+	0x458: 0xa752, 0x459: 0xa752, 0x45a: 0x1a12, 0x45b: 0x1a12, 0x45c: 0x1e12, 0x45d: 0x1e12,
+	0x45e: 0x1a12, 0x45f: 0x1a12, 0x460: 0x2612, 0x461: 0x2612, 0x462: 0x2a12, 0x463: 0x2a12,
+	0x464: 0x2e12, 0x465: 0x2e12, 0x466: 0x2a12, 0x467: 0x2a12, 0x468: 0x2612, 0x469: 0x2612,
+	// Block 0x12, offset 0x480
+	0x480: 0x6552, 0x481: 0x6552, 0x482: 0x6552, 0x483: 0x6552, 0x484: 0x6552, 0x485: 0x6552,
+	0x486: 0x6552, 0x487: 0x6552, 0x488: 0x6552, 0x489: 0x6552, 0x48a: 0x6552, 0x48b: 0x6552,
+	0x48c: 0x6552, 0x48d: 0x6552, 0x48e: 0x6552, 0x48f: 0x6552, 0x490: 0xb052, 0x491: 0xb052,
+	0x492: 0xb052, 0x493: 0xb052, 0x494: 0xb052, 0x495: 0xb052, 0x496: 0xb052, 0x497: 0xb052,
+	0x498: 0xb052, 0x499: 0xb052, 0x49a: 0xb052, 0x49b: 0xb052, 0x49c: 0xb052, 0x49d: 0xb052,
+	0x49e: 0xb052, 0x49f: 0xb052, 0x4a0: 0x0113, 0x4a1: 0x0112, 0x4a2: 0x896b, 0x4a3: 0x8b53,
+	0x4a4: 0x89cb, 0x4a5: 0x8a2a, 0x4a6: 0x8a8a, 0x4a7: 0x0f13, 0x4a8: 0x0f12, 0x4a9: 0x0313,
+	0x4aa: 0x0312, 0x4ab: 0x0713, 0x4ac: 0x0712, 0x4ad: 0x8aeb, 0x4ae: 0x8b4b, 0x4af: 0x8bab,
+	0x4b0: 0x8c0b, 0x4b1: 0x0012, 0x4b2: 0x0113, 0x4b3: 0x0112, 0x4b4: 0x0012, 0x4b5: 0x0313,
+	0x4b6: 0x0312, 0x4b7: 0x0012, 0x4b8: 0x0012, 0x4b9: 0x0012, 0x4ba: 0x0012, 0x4bb: 0x0012,
+	0x4bc: 0x0015, 0x4bd: 0x0015, 0x4be: 0x8c6b, 0x4bf: 0x8ccb,
+	// Block 0x13, offset 0x4c0
+	0x4c0: 0x0113, 0x4c1: 0x0112, 0x4c2: 0x0113, 0x4c3: 0x0112, 0x4c4: 0x0113, 0x4c5: 0x0112,
+	0x4c6: 0x0113, 0x4c7: 0x0112, 0x4c8: 0x0014, 0x4c9: 0x0014, 0x4ca: 0x0014, 0x4cb: 0x0713,
+	0x4cc: 0x0712, 0x4cd: 0x8d2b, 0x4ce: 0x0012, 0x4cf: 0x0010, 0x4d0: 0x0113, 0x4d1: 0x0112,
+	0x4d2: 0x0113, 0x4d3: 0x0112, 0x4d4: 0x6552, 0x4d5: 0x0012, 0x4d6: 0x0113, 0x4d7: 0x0112,
+	0x4d8: 0x0113, 0x4d9: 0x0112, 0x4da: 0x0113, 0x4db: 0x0112, 0x4dc: 0x0113, 0x4dd: 0x0112,
+	0x4de: 0x0113, 0x4df: 0x0112, 0x4e0: 0x0113, 0x4e1: 0x0112, 0x4e2: 0x0113, 0x4e3: 0x0112,
+	0x4e4: 0x0113, 0x4e5: 0x0112, 0x4e6: 0x0113, 0x4e7: 0x0112, 0x4e8: 0x0113, 0x4e9: 0x0112,
+	0x4ea: 0x8d8b, 0x4eb: 0x8deb, 0x4ec: 0x8e4b, 0x4ed: 0x8eab, 0x4ee: 0x8f0b, 0x4ef: 0x0012,
+	0x4f0: 0x8f6b, 0x4f1: 0x8fcb, 0x4f2: 0x902b, 0x4f3: 0xb353, 0x4f4: 0x0113, 0x4f5: 0x0112,
+	0x4f6: 0x0113, 0x4f7: 0x0112, 0x4f8: 0x0113, 0x4f9: 0x0112, 0x4fa: 0x0113, 0x4fb: 0x0112,
+	0x4fc: 0x0113, 0x4fd: 0x0112, 0x4fe: 0x0113, 0x4ff: 0x0112,
+	// Block 0x14, offset 0x500
+	0x500: 0x90ea, 0x501: 0x916a, 0x502: 0x91ea, 0x503: 0x926a, 0x504: 0x931a, 0x505: 0x93ca,
+	0x506: 0x944a,
+	0x513: 0x94ca, 0x514: 0x95aa, 0x515: 0x968a, 0x516: 0x976a, 0x517: 0x984a,
+	0x51d: 0x0010,
+	0x51e: 0x0034, 0x51f: 0x0010, 0x520: 0x0010, 0x521: 0x0010, 0x522: 0x0010, 0x523: 0x0010,
+	0x524: 0x0010, 0x525: 0x0010, 0x526: 0x0010, 0x527: 0x0010, 0x528: 0x0010,
+	0x52a: 0x0010, 0x52b: 0x0010, 0x52c: 0x0010, 0x52d: 0x0010, 0x52e: 0x0010, 0x52f: 0x0010,
+	0x530: 0x0010, 0x531: 0x0010, 0x532: 0x0010, 0x533: 0x0010, 0x534: 0x0010, 0x535: 0x0010,
+	0x536: 0x0010, 0x538: 0x0010, 0x539: 0x0010, 0x53a: 0x0010, 0x53b: 0x0010,
+	0x53c: 0x0010, 0x53e: 0x0010,
+	// Block 0x15, offset 0x540
+	0x540: 0x2713, 0x541: 0x2913, 0x542: 0x2b13, 0x543: 0x2913, 0x544: 0x2f13, 0x545: 0x2913,
+	0x546: 0x2b13, 0x547: 0x2913, 0x548: 0x2713, 0x549: 0x3913, 0x54a: 0x3b13,
+	0x54c: 0x3f13, 0x54d: 0x3913, 0x54e: 0x3b13, 0x54f: 0x3913, 0x550: 0x2713, 0x551: 0x2913,
+	0x552: 0x2b13, 0x554: 0x2f13, 0x555: 0x2913, 0x557: 0xbc52,
+	0x558: 0xbf52, 0x559: 0xc252, 0x55a: 0xbf52, 0x55b: 0xc552, 0x55c: 0xbf52, 0x55d: 0xc252,
+	0x55e: 0xbf52, 0x55f: 0xbc52, 0x560: 0xc852, 0x561: 0xcb52, 0x563: 0xce52,
+	0x564: 0xc852, 0x565: 0xcb52, 0x566: 0xc852, 0x567: 0x2712, 0x568: 0x2912, 0x569: 0x2b12,
+	0x56a: 0x2912, 0x56b: 0x2f12, 0x56c: 0x2912, 0x56d: 0x2b12, 0x56e: 0x2912, 0x56f: 0x2712,
+	0x570: 0x3912, 0x571: 0x3b12, 0x573: 0x3f12, 0x574: 0x3912, 0x575: 0x3b12,
+	0x576: 0x3912, 0x577: 0x2712, 0x578: 0x2912, 0x579: 0x2b12, 0x57b: 0x2f12,
+	0x57c: 0x2912,
+	// Block 0x16, offset 0x580
+	0x580: 0x2213, 0x581: 0x2213, 0x582: 0x2613, 0x583: 0x2613, 0x584: 0x2213, 0x585: 0x2213,
+	0x586: 0x2e13, 0x587: 0x2e13, 0x588: 0x2213, 0x589: 0x2213, 0x58a: 0x2613, 0x58b: 0x2613,
+	0x58c: 0x2213, 0x58d: 0x2213, 0x58e: 0x3e13, 0x58f: 0x3e13, 0x590: 0x2213, 0x591: 0x2213,
+	0x592: 0x2613, 0x593: 0x2613, 0x594: 0x2213, 0x595: 0x2213, 0x596: 0x2e13, 0x597: 0x2e13,
+	0x598: 0x2213, 0x599: 0x2213, 0x59a: 0x2613, 0x59b: 0x2613, 0x59c: 0x2213, 0x59d: 0x2213,
+	0x59e: 0xd153, 0x59f: 0xd153, 0x5a0: 0xd453, 0x5a1: 0xd453, 0x5a2: 0x2212, 0x5a3: 0x2212,
+	0x5a4: 0x2612, 0x5a5: 0x2612, 0x5a6: 0x2212, 0x5a7: 0x2212, 0x5a8: 0x2e12, 0x5a9: 0x2e12,
+	0x5aa: 0x2212, 0x5ab: 0x2212, 0x5ac: 0x2612, 0x5ad: 0x2612, 0x5ae: 0x2212, 0x5af: 0x2212,
+	0x5b0: 0x3e12, 0x5b1: 0x3e12, 0x5b2: 0x2212, 0x5b3: 0x2212, 0x5b4: 0x2612, 0x5b5: 0x2612,
+	0x5b6: 0x2212, 0x5b7: 0x2212, 0x5b8: 0x2e12, 0x5b9: 0x2e12, 0x5ba: 0x2212, 0x5bb: 0x2212,
+	0x5bc: 0x2612, 0x5bd: 0x2612, 0x5be: 0x2212, 0x5bf: 0x2212,
+	// Block 0x17, offset 0x5c0
+	0x5c2: 0x0010,
+	0x5c7: 0x0010, 0x5c9: 0x0010, 0x5cb: 0x0010,
+	0x5cd: 0x0010, 0x5ce: 0x0010, 0x5cf: 0x0010, 0x5d1: 0x0010,
+	0x5d2: 0x0010, 0x5d4: 0x0010, 0x5d7: 0x0010,
+	0x5d9: 0x0010, 0x5db: 0x0010, 0x5dd: 0x0010,
+	0x5df: 0x0010, 0x5e1: 0x0010, 0x5e2: 0x0010,
+	0x5e4: 0x0010, 0x5e7: 0x0010, 0x5e8: 0x0010, 0x5e9: 0x0010,
+	0x5ea: 0x0010, 0x5ec: 0x0010, 0x5ed: 0x0010, 0x5ee: 0x0010, 0x5ef: 0x0010,
+	0x5f0: 0x0010, 0x5f1: 0x0010, 0x5f2: 0x0010, 0x5f4: 0x0010, 0x5f5: 0x0010,
+	0x5f6: 0x0010, 0x5f7: 0x0010, 0x5f9: 0x0010, 0x5fa: 0x0010, 0x5fb: 0x0010,
+	0x5fc: 0x0010, 0x5fe: 0x0010,
+}
+
+// caseIndex: 27 blocks, 1728 entries, 3456 bytes
+// Block 0 is the zero block.
+var caseIndex = [1728]uint16{
+	// Block 0x0, offset 0x0
+	// Block 0x1, offset 0x40
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc2: 0x16, 0xc3: 0x17, 0xc4: 0x18, 0xc5: 0x19, 0xc6: 0x01, 0xc7: 0x02,
+	0xc8: 0x1a, 0xc9: 0x03, 0xca: 0x04, 0xcb: 0x1b, 0xcc: 0x1c, 0xcd: 0x05, 0xce: 0x06, 0xcf: 0x07,
+	0xd0: 0x1d, 0xd1: 0x1e, 0xd2: 0x1f, 0xd3: 0x20, 0xd4: 0x21, 0xd5: 0x22, 0xd6: 0x08, 0xd7: 0x23,
+	0xd8: 0x24, 0xd9: 0x25, 0xda: 0x26, 0xdb: 0x27, 0xdc: 0x28, 0xdd: 0x29, 0xde: 0x2a, 0xdf: 0x2b,
+	0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05,
+	0xea: 0x06, 0xeb: 0x07, 0xec: 0x07, 0xed: 0x08, 0xef: 0x09,
+	0xf0: 0x16, 0xf3: 0x18,
+	// Block 0x4, offset 0x100
+	0x120: 0x2c, 0x121: 0x2d, 0x122: 0x2e, 0x123: 0x09, 0x124: 0x2f, 0x125: 0x30, 0x126: 0x31, 0x127: 0x32,
+	0x128: 0x33, 0x129: 0x34, 0x12a: 0x35, 0x12b: 0x36, 0x12c: 0x37, 0x12d: 0x38, 0x12e: 0x39, 0x12f: 0x3a,
+	0x130: 0x3b, 0x131: 0x3c, 0x132: 0x3d, 0x133: 0x3e, 0x134: 0x3f, 0x135: 0x40, 0x136: 0x41, 0x137: 0x42,
+	0x138: 0x43, 0x139: 0x44, 0x13a: 0x45, 0x13b: 0x46, 0x13c: 0x47, 0x13d: 0x48, 0x13e: 0x49, 0x13f: 0x4a,
+	// Block 0x5, offset 0x140
+	0x140: 0x4b, 0x141: 0x4c, 0x142: 0x4d, 0x143: 0x0a, 0x144: 0x26, 0x145: 0x26, 0x146: 0x26, 0x147: 0x26,
+	0x148: 0x26, 0x149: 0x4e, 0x14a: 0x4f, 0x14b: 0x50, 0x14c: 0x51, 0x14d: 0x52, 0x14e: 0x53, 0x14f: 0x54,
+	0x150: 0x55, 0x151: 0x26, 0x152: 0x26, 0x153: 0x26, 0x154: 0x26, 0x155: 0x26, 0x156: 0x26, 0x157: 0x26,
+	0x158: 0x26, 0x159: 0x56, 0x15a: 0x57, 0x15b: 0x58, 0x15c: 0x59, 0x15d: 0x5a, 0x15e: 0x5b, 0x15f: 0x5c,
+	0x160: 0x5d, 0x161: 0x5e, 0x162: 0x5f, 0x163: 0x60, 0x164: 0x61, 0x165: 0x62, 0x167: 0x63,
+	0x168: 0x64, 0x169: 0x65, 0x16a: 0x66, 0x16b: 0x67, 0x16c: 0x68, 0x16d: 0x69, 0x16e: 0x6a, 0x16f: 0x6b,
+	0x170: 0x6c, 0x171: 0x6d, 0x172: 0x6e, 0x173: 0x6f, 0x174: 0x70, 0x175: 0x71, 0x176: 0x72, 0x177: 0x73,
+	0x178: 0x74, 0x179: 0x74, 0x17a: 0x75, 0x17b: 0x74, 0x17c: 0x76, 0x17d: 0x0b, 0x17e: 0x0c, 0x17f: 0x0d,
+	// Block 0x6, offset 0x180
+	0x180: 0x77, 0x181: 0x78, 0x182: 0x79, 0x183: 0x7a, 0x184: 0x0e, 0x185: 0x7b, 0x186: 0x7c,
+	0x192: 0x7d, 0x193: 0x0f,
+	0x1b0: 0x7e, 0x1b1: 0x10, 0x1b2: 0x74, 0x1b3: 0x7f, 0x1b4: 0x80, 0x1b5: 0x81, 0x1b6: 0x82, 0x1b7: 0x83,
+	0x1b8: 0x84,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x85, 0x1c2: 0x86, 0x1c3: 0x87, 0x1c4: 0x88, 0x1c5: 0x26, 0x1c6: 0x89,
+	// Block 0x8, offset 0x200
+	0x200: 0x8a, 0x201: 0x26, 0x202: 0x26, 0x203: 0x26, 0x204: 0x26, 0x205: 0x26, 0x206: 0x26, 0x207: 0x26,
+	0x208: 0x26, 0x209: 0x26, 0x20a: 0x26, 0x20b: 0x26, 0x20c: 0x26, 0x20d: 0x26, 0x20e: 0x26, 0x20f: 0x26,
+	0x210: 0x26, 0x211: 0x26, 0x212: 0x8b, 0x213: 0x8c, 0x214: 0x26, 0x215: 0x26, 0x216: 0x26, 0x217: 0x26,
+	0x218: 0x8d, 0x219: 0x8e, 0x21a: 0x8f, 0x21b: 0x90, 0x21c: 0x91, 0x21d: 0x92, 0x21e: 0x11, 0x21f: 0x93,
+	0x220: 0x94, 0x221: 0x95, 0x222: 0x26, 0x223: 0x96, 0x224: 0x97, 0x225: 0x98, 0x226: 0x99, 0x227: 0x9a,
+	0x228: 0x9b, 0x229: 0x9c, 0x22a: 0x9d, 0x22b: 0x9e, 0x22c: 0x9f, 0x22d: 0xa0, 0x22e: 0xa1, 0x22f: 0xa2,
+	0x230: 0x26, 0x231: 0x26, 0x232: 0x26, 0x233: 0x26, 0x234: 0x26, 0x235: 0x26, 0x236: 0x26, 0x237: 0x26,
+	0x238: 0x26, 0x239: 0x26, 0x23a: 0x26, 0x23b: 0x26, 0x23c: 0x26, 0x23d: 0x26, 0x23e: 0x26, 0x23f: 0x26,
+	// Block 0x9, offset 0x240
+	0x240: 0x26, 0x241: 0x26, 0x242: 0x26, 0x243: 0x26, 0x244: 0x26, 0x245: 0x26, 0x246: 0x26, 0x247: 0x26,
+	0x248: 0x26, 0x249: 0x26, 0x24a: 0x26, 0x24b: 0x26, 0x24c: 0x26, 0x24d: 0x26, 0x24e: 0x26, 0x24f: 0x26,
+	0x250: 0x26, 0x251: 0x26, 0x252: 0x26, 0x253: 0x26, 0x254: 0x26, 0x255: 0x26, 0x256: 0x26, 0x257: 0x26,
+	0x258: 0x26, 0x259: 0x26, 0x25a: 0x26, 0x25b: 0x26, 0x25c: 0x26, 0x25d: 0x26, 0x25e: 0x26, 0x25f: 0x26,
+	0x260: 0x26, 0x261: 0x26, 0x262: 0x26, 0x263: 0x26, 0x264: 0x26, 0x265: 0x26, 0x266: 0x26, 0x267: 0x26,
+	0x268: 0x26, 0x269: 0x26, 0x26a: 0x26, 0x26b: 0x26, 0x26c: 0x26, 0x26d: 0x26, 0x26e: 0x26, 0x26f: 0x26,
+	0x270: 0x26, 0x271: 0x26, 0x272: 0x26, 0x273: 0x26, 0x274: 0x26, 0x275: 0x26, 0x276: 0x26, 0x277: 0x26,
+	0x278: 0x26, 0x279: 0x26, 0x27a: 0x26, 0x27b: 0x26, 0x27c: 0x26, 0x27d: 0x26, 0x27e: 0x26, 0x27f: 0x26,
+	// Block 0xa, offset 0x280
+	0x280: 0x26, 0x281: 0x26, 0x282: 0x26, 0x283: 0x26, 0x284: 0x26, 0x285: 0x26, 0x286: 0x26, 0x287: 0x26,
+	0x288: 0x26, 0x289: 0x26, 0x28a: 0x26, 0x28b: 0x26, 0x28c: 0x26, 0x28d: 0x26, 0x28e: 0x26, 0x28f: 0x26,
+	0x290: 0x26, 0x291: 0x26, 0x292: 0x26, 0x293: 0x26, 0x294: 0x26, 0x295: 0x26, 0x296: 0x26, 0x297: 0x26,
+	0x298: 0x26, 0x299: 0x26, 0x29a: 0x26, 0x29b: 0x26, 0x29c: 0x26, 0x29d: 0x26, 0x29e: 0xa3, 0x29f: 0xa4,
+	// Block 0xb, offset 0x2c0
+	0x2ec: 0x12, 0x2ed: 0xa5, 0x2ee: 0xa6, 0x2ef: 0xa7,
+	0x2f0: 0x26, 0x2f1: 0x26, 0x2f2: 0x26, 0x2f3: 0x26, 0x2f4: 0xa8, 0x2f5: 0xa9, 0x2f6: 0xaa, 0x2f7: 0xab,
+	0x2f8: 0xac, 0x2f9: 0xad, 0x2fa: 0x26, 0x2fb: 0xae, 0x2fc: 0xaf, 0x2fd: 0xb0, 0x2fe: 0xb1, 0x2ff: 0xb2,
+	// Block 0xc, offset 0x300
+	0x300: 0xb3, 0x301: 0xb4, 0x302: 0x26, 0x303: 0xb5, 0x305: 0xb6, 0x307: 0xb7,
+	0x30a: 0xb8, 0x30b: 0xb9, 0x30c: 0xba, 0x30d: 0xbb, 0x30e: 0xbc, 0x30f: 0xbd,
+	0x310: 0xbe, 0x311: 0xbf, 0x312: 0xc0, 0x313: 0xc1, 0x314: 0xc2, 0x315: 0xc3, 0x316: 0x13,
+	0x318: 0x26, 0x319: 0x26, 0x31a: 0x26, 0x31b: 0x26, 0x31c: 0xc4, 0x31d: 0xc5, 0x31e: 0xc6,
+	0x320: 0xc7, 0x321: 0xc8, 0x322: 0xc9, 0x323: 0xca, 0x324: 0xcb, 0x326: 0xcc,
+	0x328: 0xcd, 0x329: 0xce, 0x32a: 0xcf, 0x32b: 0xd0, 0x32c: 0x60, 0x32d: 0xd1, 0x32e: 0xd2,
+	0x330: 0x26, 0x331: 0xd3, 0x332: 0xd4, 0x333: 0xd5, 0x334: 0xd6,
+	0x33a: 0xd7, 0x33b: 0xd8, 0x33c: 0xd9, 0x33d: 0xda, 0x33e: 0xdb, 0x33f: 0xdc,
+	// Block 0xd, offset 0x340
+	0x340: 0xdd, 0x341: 0xde, 0x342: 0xdf, 0x343: 0xe0, 0x344: 0xe1, 0x345: 0xe2, 0x346: 0xe3, 0x347: 0xe4,
+	0x348: 0xe5, 0x349: 0xe6, 0x34a: 0xe7, 0x34b: 0xe8, 0x34c: 0xe9, 0x34d: 0xea,
+	0x350: 0xeb, 0x351: 0xec, 0x352: 0xed, 0x353: 0xee, 0x356: 0xef, 0x357: 0xf0,
+	0x358: 0xf1, 0x359: 0xf2, 0x35a: 0xf3, 0x35b: 0xf4, 0x35c: 0xf5,
+	0x360: 0xf6, 0x362: 0xf7, 0x363: 0xf8, 0x364: 0xf9, 0x365: 0xfa, 0x366: 0xfb, 0x367: 0xfc,
+	0x368: 0xfd, 0x369: 0xfe, 0x36a: 0xff, 0x36b: 0x100,
+	0x370: 0x101, 0x371: 0x102, 0x372: 0x103, 0x374: 0x104, 0x375: 0x105, 0x376: 0x106,
+	0x37b: 0x107, 0x37c: 0x108, 0x37d: 0x109, 0x37e: 0x10a,
+	// Block 0xe, offset 0x380
+	0x380: 0x26, 0x381: 0x26, 0x382: 0x26, 0x383: 0x26, 0x384: 0x26, 0x385: 0x26, 0x386: 0x26, 0x387: 0x26,
+	0x388: 0x26, 0x389: 0x26, 0x38a: 0x26, 0x38b: 0x26, 0x38c: 0x26, 0x38d: 0x26, 0x38e: 0x10b,
+	0x390: 0x26, 0x391: 0x10c, 0x392: 0x26, 0x393: 0x26, 0x394: 0x26, 0x395: 0x10d,
+	0x3be: 0xa9, 0x3bf: 0x10e,
+	// Block 0xf, offset 0x3c0
+	0x3c0: 0x26, 0x3c1: 0x26, 0x3c2: 0x26, 0x3c3: 0x26, 0x3c4: 0x26, 0x3c5: 0x26, 0x3c6: 0x26, 0x3c7: 0x26,
+	0x3c8: 0x26, 0x3c9: 0x26, 0x3ca: 0x26, 0x3cb: 0x26, 0x3cc: 0x26, 0x3cd: 0x26, 0x3ce: 0x26, 0x3cf: 0x26,
+	0x3d0: 0x10f, 0x3d1: 0x110,
+	// Block 0x10, offset 0x400
+	0x410: 0x26, 0x411: 0x26, 0x412: 0x26, 0x413: 0x26, 0x414: 0x26, 0x415: 0x26, 0x416: 0x26, 0x417: 0x26,
+	0x418: 0x26, 0x419: 0x111,
+	// Block 0x11, offset 0x440
+	0x460: 0x26, 0x461: 0x26, 0x462: 0x26, 0x463: 0x26, 0x464: 0x26, 0x465: 0x26, 0x466: 0x26, 0x467: 0x26,
+	0x468: 0x100, 0x469: 0x112, 0x46a: 0x113, 0x46b: 0x114, 0x46c: 0x115, 0x46d: 0x116, 0x46e: 0x117,
+	0x479: 0x118, 0x47c: 0x26, 0x47d: 0x119, 0x47e: 0x11a, 0x47f: 0x11b,
+	// Block 0x12, offset 0x480
+	0x4bf: 0x11c,
+	// Block 0x13, offset 0x4c0
+	0x4f0: 0x26, 0x4f1: 0x11d, 0x4f2: 0x11e,
+	// Block 0x14, offset 0x500
+	0x53c: 0x11f, 0x53d: 0x120,
+	// Block 0x15, offset 0x540
+	0x545: 0x121, 0x546: 0x122,
+	0x549: 0x123,
+	0x550: 0x124, 0x551: 0x125, 0x552: 0x126, 0x553: 0x127, 0x554: 0x128, 0x555: 0x129, 0x556: 0x12a, 0x557: 0x12b,
+	0x558: 0x12c, 0x559: 0x12d, 0x55a: 0x12e, 0x55b: 0x12f, 0x55c: 0x130, 0x55d: 0x131, 0x55e: 0x132, 0x55f: 0x133,
+	0x568: 0x134, 0x569: 0x135, 0x56a: 0x136,
+	0x57c: 0x137,
+	// Block 0x16, offset 0x580
+	0x580: 0x138, 0x581: 0x139, 0x582: 0x13a, 0x584: 0x13b, 0x585: 0x13c,
+	0x58a: 0x13d, 0x58b: 0x13e,
+	0x593: 0x13f,
+	0x59f: 0x140,
+	0x5a0: 0x26, 0x5a1: 0x26, 0x5a2: 0x26, 0x5a3: 0x141, 0x5a4: 0x14, 0x5a5: 0x142,
+	0x5b8: 0x143, 0x5b9: 0x15, 0x5ba: 0x144,
+	// Block 0x17, offset 0x5c0
+	0x5c4: 0x145, 0x5c5: 0x146, 0x5c6: 0x147,
+	0x5cf: 0x148,
+	0x5ef: 0x149,
+	// Block 0x18, offset 0x600
+	0x610: 0x0a, 0x611: 0x0b, 0x612: 0x0c, 0x613: 0x0d, 0x614: 0x0e, 0x616: 0x0f,
+	0x61a: 0x10, 0x61b: 0x11, 0x61c: 0x12, 0x61d: 0x13, 0x61e: 0x14, 0x61f: 0x15,
+	// Block 0x19, offset 0x640
+	0x640: 0x14a, 0x641: 0x14b, 0x644: 0x14b, 0x645: 0x14b, 0x646: 0x14b, 0x647: 0x14c,
+	// Block 0x1a, offset 0x680
+	0x6a0: 0x17,
+}
+
+// sparseOffsets: 312 entries, 624 bytes
+var sparseOffsets = []uint16{0x0, 0x9, 0xf, 0x18, 0x24, 0x2e, 0x34, 0x37, 0x3b, 0x3e, 0x42, 0x4c, 0x4e, 0x57, 0x5e, 0x63, 0x71, 0x72, 0x80, 0x8f, 0x99, 0x9c, 0xa3, 0xab, 0xaf, 0xb7, 0xbd, 0xcb, 0xd6, 0xe3, 0xee, 0xfa, 0x104, 0x110, 0x11b, 0x127, 0x133, 0x13b, 0x145, 0x150, 0x15b, 0x167, 0x16d, 0x178, 0x17e, 0x186, 0x189, 0x18e, 0x192, 0x196, 0x19d, 0x1a6, 0x1ae, 0x1af, 0x1b8, 0x1bf, 0x1c7, 0x1cd, 0x1d2, 0x1d6, 0x1d9, 0x1db, 0x1de, 0x1e3, 0x1e4, 0x1e6, 0x1e8, 0x1ea, 0x1f1, 0x1f6, 0x1fa, 0x203, 0x206, 0x209, 0x20f, 0x210, 0x21b, 0x21c, 0x21d, 0x222, 0x22f, 0x238, 0x23e, 0x246, 0x24f, 0x258, 0x261, 0x266, 0x269, 0x274, 0x282, 0x284, 0x28b, 0x28f, 0x29b, 0x29c, 0x2a7, 0x2af, 0x2b7, 0x2bd, 0x2be, 0x2cc, 0x2d1, 0x2d4, 0x2d9, 0x2dd, 0x2e3, 0x2e8, 0x2eb, 0x2f0, 0x2f5, 0x2f6, 0x2fc, 0x2fe, 0x2ff, 0x301, 0x303, 0x306, 0x307, 0x309, 0x30c, 0x312, 0x316, 0x318, 0x31d, 0x324, 0x334, 0x33e, 0x33f, 0x348, 0x34c, 0x351, 0x359, 0x35f, 0x365, 0x36f, 0x374, 0x37d, 0x383, 0x38c, 0x390, 0x398, 0x39a, 0x39c, 0x39f, 0x3a1, 0x3a3, 0x3a4, 0x3a5, 0x3a7, 0x3a9, 0x3af, 0x3b4, 0x3b6, 0x3bd, 0x3c0, 0x3c2, 0x3c8, 0x3cd, 0x3cf, 0x3d0, 0x3d1, 0x3d2, 0x3d4, 0x3d6, 0x3d8, 0x3db, 0x3dd, 0x3e0, 0x3e8, 0x3eb, 0x3ef, 0x3f7, 0x3f9, 0x409, 0x40a, 0x40c, 0x411, 0x417, 0x419, 0x41a, 0x41c, 0x41e, 0x420, 0x42d, 0x42e, 0x42f, 0x433, 0x435, 0x436, 0x437, 0x438, 0x439, 0x43c, 0x43f, 0x440, 0x443, 0x44a, 0x450, 0x452, 0x456, 0x45e, 0x464, 0x468, 0x46f, 0x473, 0x477, 0x480, 0x48a, 0x48c, 0x492, 0x498, 0x4a2, 0x4ac, 0x4ae, 0x4b7, 0x4bd, 0x4c3, 0x4c9, 0x4cc, 0x4d2, 0x4d5, 0x4de, 0x4df, 0x4e6, 0x4ea, 0x4eb, 0x4ee, 0x4f8, 0x4fb, 0x4fd, 0x504, 0x50c, 0x512, 0x519, 0x51a, 0x520, 0x523, 0x52b, 0x532, 0x53c, 0x544, 0x547, 0x54c, 0x550, 0x551, 0x552, 0x553, 0x554, 0x555, 0x557, 0x55a, 0x55b, 0x55e, 0x55f, 0x562, 0x564, 0x568, 0x569, 0x56b, 0x56e, 0x570, 0x573, 0x576, 0x578, 0x57d, 0x57f, 0x580, 0x585, 0x589, 0x58a, 0x58d, 0x591, 0x59c, 0x5a0, 0x5a8, 0x5ad, 0x5b1, 0x5b4, 0x5b8, 0x5bb, 0x5be, 0x5c3, 0x5c7, 0x5cb, 0x5cf, 0x5d3, 0x5d5, 0x5d7, 0x5da, 0x5de, 0x5e4, 0x5e5, 0x5e6, 0x5e9, 0x5eb, 0x5ed, 0x5f0, 0x5f5, 0x5f9, 0x5fb, 0x601, 0x60a, 0x60f, 0x610, 0x613, 0x614, 0x615, 0x616, 0x618, 0x619, 0x61a}
+
+// sparseValues: 1562 entries, 6248 bytes
+var sparseValues = [1562]valueRange{
+	// Block 0x0, offset 0x0
+	{value: 0x0004, lo: 0xa8, hi: 0xa8},
+	{value: 0x0012, lo: 0xaa, hi: 0xaa},
+	{value: 0x0014, lo: 0xad, hi: 0xad},
+	{value: 0x0004, lo: 0xaf, hi: 0xaf},
+	{value: 0x0004, lo: 0xb4, hi: 0xb4},
+	{value: 0x001a, lo: 0xb5, hi: 0xb5},
+	{value: 0x0054, lo: 0xb7, hi: 0xb7},
+	{value: 0x0004, lo: 0xb8, hi: 0xb8},
+	{value: 0x0012, lo: 0xba, hi: 0xba},
+	// Block 0x1, offset 0x9
+	{value: 0x2013, lo: 0x80, hi: 0x96},
+	{value: 0x2013, lo: 0x98, hi: 0x9e},
+	{value: 0x009a, lo: 0x9f, hi: 0x9f},
+	{value: 0x2012, lo: 0xa0, hi: 0xb6},
+	{value: 0x2012, lo: 0xb8, hi: 0xbe},
+	{value: 0x0252, lo: 0xbf, hi: 0xbf},
+	// Block 0x2, offset 0xf
+	{value: 0x0117, lo: 0x80, hi: 0xaf},
+	{value: 0x011b, lo: 0xb0, hi: 0xb0},
+	{value: 0x019a, lo: 0xb1, hi: 0xb1},
+	{value: 0x0117, lo: 0xb2, hi: 0xb7},
+	{value: 0x0012, lo: 0xb8, hi: 0xb8},
+	{value: 0x0316, lo: 0xb9, hi: 0xba},
+	{value: 0x0716, lo: 0xbb, hi: 0xbc},
+	{value: 0x0316, lo: 0xbd, hi: 0xbe},
+	{value: 0x0553, lo: 0xbf, hi: 0xbf},
+	// Block 0x3, offset 0x18
+	{value: 0x0552, lo: 0x80, hi: 0x80},
+	{value: 0x0316, lo: 0x81, hi: 0x82},
+	{value: 0x0716, lo: 0x83, hi: 0x84},
+	{value: 0x0316, lo: 0x85, hi: 0x86},
+	{value: 0x0f16, lo: 0x87, hi: 0x88},
+	{value: 0x01da, lo: 0x89, hi: 0x89},
+	{value: 0x0117, lo: 0x8a, hi: 0xb7},
+	{value: 0x0253, lo: 0xb8, hi: 0xb8},
+	{value: 0x0316, lo: 0xb9, hi: 0xba},
+	{value: 0x0716, lo: 0xbb, hi: 0xbc},
+	{value: 0x0316, lo: 0xbd, hi: 0xbe},
+	{value: 0x028a, lo: 0xbf, hi: 0xbf},
+	// Block 0x4, offset 0x24
+	{value: 0x0117, lo: 0x80, hi: 0x9f},
+	{value: 0x2f53, lo: 0xa0, hi: 0xa0},
+	{value: 0x0012, lo: 0xa1, hi: 0xa1},
+	{value: 0x0117, lo: 0xa2, hi: 0xb3},
+	{value: 0x0012, lo: 0xb4, hi: 0xb9},
+	{value: 0x090b, lo: 0xba, hi: 0xba},
+	{value: 0x0716, lo: 0xbb, hi: 0xbc},
+	{value: 0x2953, lo: 0xbd, hi: 0xbd},
+	{value: 0x098b, lo: 0xbe, hi: 0xbe},
+	{value: 0x0a0a, lo: 0xbf, hi: 0xbf},
+	// Block 0x5, offset 0x2e
+	{value: 0x0015, lo: 0x80, hi: 0x81},
+	{value: 0x0014, lo: 0x82, hi: 0x97},
+	{value: 0x0004, lo: 0x98, hi: 0x9d},
+	{value: 0x0014, lo: 0x9e, hi: 0x9f},
+	{value: 0x0015, lo: 0xa0, hi: 0xa4},
+	{value: 0x0014, lo: 0xa5, hi: 0xbf},
+	// Block 0x6, offset 0x34
+	{value: 0x0024, lo: 0x80, hi: 0x94},
+	{value: 0x0034, lo: 0x95, hi: 0xbc},
+	{value: 0x0024, lo: 0xbd, hi: 0xbf},
+	// Block 0x7, offset 0x37
+	{value: 0x6553, lo: 0x80, hi: 0x8f},
+	{value: 0x2013, lo: 0x90, hi: 0x9f},
+	{value: 0x5f53, lo: 0xa0, hi: 0xaf},
+	{value: 0x2012, lo: 0xb0, hi: 0xbf},
+	// Block 0x8, offset 0x3b
+	{value: 0x5f52, lo: 0x80, hi: 0x8f},
+	{value: 0x6552, lo: 0x90, hi: 0x9f},
+	{value: 0x0117, lo: 0xa0, hi: 0xbf},
+	// Block 0x9, offset 0x3e
+	{value: 0x0117, lo: 0x80, hi: 0x81},
+	{value: 0x0024, lo: 0x83, hi: 0x87},
+	{value: 0x0014, lo: 0x88, hi: 0x89},
+	{value: 0x0117, lo: 0x8a, hi: 0xbf},
+	// Block 0xa, offset 0x42
+	{value: 0x0f13, lo: 0x80, hi: 0x80},
+	{value: 0x0316, lo: 0x81, hi: 0x82},
+	{value: 0x0716, lo: 0x83, hi: 0x84},
+	{value: 0x0316, lo: 0x85, hi: 0x86},
+	{value: 0x0f16, lo: 0x87, hi: 0x88},
+	{value: 0x0316, lo: 0x89, hi: 0x8a},
+	{value: 0x0716, lo: 0x8b, hi: 0x8c},
+	{value: 0x0316, lo: 0x8d, hi: 0x8e},
+	{value: 0x0f12, lo: 0x8f, hi: 0x8f},
+	{value: 0x0117, lo: 0x90, hi: 0xbf},
+	// Block 0xb, offset 0x4c
+	{value: 0x0117, lo: 0x80, hi: 0xaf},
+	{value: 0x6553, lo: 0xb1, hi: 0xbf},
+	// Block 0xc, offset 0x4e
+	{value: 0x3013, lo: 0x80, hi: 0x8f},
+	{value: 0x6853, lo: 0x90, hi: 0x96},
+	{value: 0x0014, lo: 0x99, hi: 0x99},
+	{value: 0x0010, lo: 0x9a, hi: 0x9c},
+	{value: 0x0010, lo: 0x9e, hi: 0x9e},
+	{value: 0x0054, lo: 0x9f, hi: 0x9f},
+	{value: 0x0012, lo: 0xa0, hi: 0xa0},
+	{value: 0x6552, lo: 0xa1, hi: 0xaf},
+	{value: 0x3012, lo: 0xb0, hi: 0xbf},
+	// Block 0xd, offset 0x57
+	{value: 0x0034, lo: 0x81, hi: 0x82},
+	{value: 0x0024, lo: 0x84, hi: 0x84},
+	{value: 0x0034, lo: 0x85, hi: 0x85},
+	{value: 0x0034, lo: 0x87, hi: 0x87},
+	{value: 0x0010, lo: 0x90, hi: 0xaa},
+	{value: 0x0010, lo: 0xaf, hi: 0xb3},
+	{value: 0x0054, lo: 0xb4, hi: 0xb4},
+	// Block 0xe, offset 0x5e
+	{value: 0x0014, lo: 0x80, hi: 0x85},
+	{value: 0x0024, lo: 0x90, hi: 0x97},
+	{value: 0x0034, lo: 0x98, hi: 0x9a},
+	{value: 0x0014, lo: 0x9c, hi: 0x9c},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0xf, offset 0x63
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x8a},
+	{value: 0x0034, lo: 0x8b, hi: 0x92},
+	{value: 0x0024, lo: 0x93, hi: 0x94},
+	{value: 0x0034, lo: 0x95, hi: 0x96},
+	{value: 0x0024, lo: 0x97, hi: 0x9b},
+	{value: 0x0034, lo: 0x9c, hi: 0x9c},
+	{value: 0x0024, lo: 0x9d, hi: 0x9e},
+	{value: 0x0034, lo: 0x9f, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	{value: 0x0010, lo: 0xab, hi: 0xab},
+	{value: 0x0010, lo: 0xae, hi: 0xaf},
+	{value: 0x0034, lo: 0xb0, hi: 0xb0},
+	{value: 0x0010, lo: 0xb1, hi: 0xbf},
+	// Block 0x10, offset 0x71
+	{value: 0x0010, lo: 0x80, hi: 0xbf},
+	// Block 0x11, offset 0x72
+	{value: 0x0010, lo: 0x80, hi: 0x93},
+	{value: 0x0010, lo: 0x95, hi: 0x95},
+	{value: 0x0024, lo: 0x96, hi: 0x9c},
+	{value: 0x0014, lo: 0x9d, hi: 0x9d},
+	{value: 0x0024, lo: 0x9f, hi: 0xa2},
+	{value: 0x0034, lo: 0xa3, hi: 0xa3},
+	{value: 0x0024, lo: 0xa4, hi: 0xa4},
+	{value: 0x0014, lo: 0xa5, hi: 0xa6},
+	{value: 0x0024, lo: 0xa7, hi: 0xa8},
+	{value: 0x0034, lo: 0xaa, hi: 0xaa},
+	{value: 0x0024, lo: 0xab, hi: 0xac},
+	{value: 0x0034, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xbc},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0x12, offset 0x80
+	{value: 0x0014, lo: 0x8f, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0x90},
+	{value: 0x0034, lo: 0x91, hi: 0x91},
+	{value: 0x0010, lo: 0x92, hi: 0xaf},
+	{value: 0x0024, lo: 0xb0, hi: 0xb0},
+	{value: 0x0034, lo: 0xb1, hi: 0xb1},
+	{value: 0x0024, lo: 0xb2, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	{value: 0x0024, lo: 0xb5, hi: 0xb6},
+	{value: 0x0034, lo: 0xb7, hi: 0xb9},
+	{value: 0x0024, lo: 0xba, hi: 0xba},
+	{value: 0x0034, lo: 0xbb, hi: 0xbc},
+	{value: 0x0024, lo: 0xbd, hi: 0xbd},
+	{value: 0x0034, lo: 0xbe, hi: 0xbe},
+	{value: 0x0024, lo: 0xbf, hi: 0xbf},
+	// Block 0x13, offset 0x8f
+	{value: 0x0024, lo: 0x80, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x82},
+	{value: 0x0024, lo: 0x83, hi: 0x83},
+	{value: 0x0034, lo: 0x84, hi: 0x84},
+	{value: 0x0024, lo: 0x85, hi: 0x85},
+	{value: 0x0034, lo: 0x86, hi: 0x86},
+	{value: 0x0024, lo: 0x87, hi: 0x87},
+	{value: 0x0034, lo: 0x88, hi: 0x88},
+	{value: 0x0024, lo: 0x89, hi: 0x8a},
+	{value: 0x0010, lo: 0x8d, hi: 0xbf},
+	// Block 0x14, offset 0x99
+	{value: 0x0010, lo: 0x80, hi: 0xa5},
+	{value: 0x0014, lo: 0xa6, hi: 0xb0},
+	{value: 0x0010, lo: 0xb1, hi: 0xb1},
+	// Block 0x15, offset 0x9c
+	{value: 0x0010, lo: 0x80, hi: 0xaa},
+	{value: 0x0024, lo: 0xab, hi: 0xb1},
+	{value: 0x0034, lo: 0xb2, hi: 0xb2},
+	{value: 0x0024, lo: 0xb3, hi: 0xb3},
+	{value: 0x0014, lo: 0xb4, hi: 0xb5},
+	{value: 0x0014, lo: 0xba, hi: 0xba},
+	{value: 0x0034, lo: 0xbd, hi: 0xbd},
+	// Block 0x16, offset 0xa3
+	{value: 0x0010, lo: 0x80, hi: 0x95},
+	{value: 0x0024, lo: 0x96, hi: 0x99},
+	{value: 0x0014, lo: 0x9a, hi: 0x9a},
+	{value: 0x0024, lo: 0x9b, hi: 0xa3},
+	{value: 0x0014, lo: 0xa4, hi: 0xa4},
+	{value: 0x0024, lo: 0xa5, hi: 0xa7},
+	{value: 0x0014, lo: 0xa8, hi: 0xa8},
+	{value: 0x0024, lo: 0xa9, hi: 0xad},
+	// Block 0x17, offset 0xab
+	{value: 0x0010, lo: 0x80, hi: 0x98},
+	{value: 0x0034, lo: 0x99, hi: 0x9b},
+	{value: 0x0010, lo: 0xa0, hi: 0xaa},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0x18, offset 0xaf
+	{value: 0x0010, lo: 0x80, hi: 0x87},
+	{value: 0x0004, lo: 0x88, hi: 0x88},
+	{value: 0x0010, lo: 0x89, hi: 0x8e},
+	{value: 0x0014, lo: 0x90, hi: 0x91},
+	{value: 0x0024, lo: 0x98, hi: 0x98},
+	{value: 0x0034, lo: 0x99, hi: 0x9b},
+	{value: 0x0024, lo: 0x9c, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x19, offset 0xb7
+	{value: 0x0014, lo: 0x80, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0xb9},
+	{value: 0x0014, lo: 0xba, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbb},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x1a, offset 0xbd
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x88},
+	{value: 0x0010, lo: 0x89, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x8e, hi: 0x90},
+	{value: 0x0024, lo: 0x91, hi: 0x91},
+	{value: 0x0034, lo: 0x92, hi: 0x92},
+	{value: 0x0024, lo: 0x93, hi: 0x94},
+	{value: 0x0014, lo: 0x95, hi: 0x97},
+	{value: 0x0010, lo: 0x98, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0014, lo: 0xb1, hi: 0xb1},
+	{value: 0x0010, lo: 0xb2, hi: 0xbf},
+	// Block 0x1b, offset 0xcb
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x8f, hi: 0x90},
+	{value: 0x0010, lo: 0x93, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb2},
+	{value: 0x0010, lo: 0xb6, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x1c, offset 0xd6
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x84},
+	{value: 0x0010, lo: 0x87, hi: 0x88},
+	{value: 0x0010, lo: 0x8b, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x8e, hi: 0x8e},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0010, lo: 0x9c, hi: 0x9d},
+	{value: 0x0010, lo: 0x9f, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xb1},
+	{value: 0x0010, lo: 0xbc, hi: 0xbc},
+	{value: 0x0024, lo: 0xbe, hi: 0xbe},
+	// Block 0x1d, offset 0xe3
+	{value: 0x0014, lo: 0x81, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8a},
+	{value: 0x0010, lo: 0x8f, hi: 0x90},
+	{value: 0x0010, lo: 0x93, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	{value: 0x0010, lo: 0xb5, hi: 0xb6},
+	{value: 0x0010, lo: 0xb8, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0x1e, offset 0xee
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x82},
+	{value: 0x0014, lo: 0x87, hi: 0x88},
+	{value: 0x0014, lo: 0x8b, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0014, lo: 0x91, hi: 0x91},
+	{value: 0x0010, lo: 0x99, hi: 0x9c},
+	{value: 0x0010, lo: 0x9e, hi: 0x9e},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0014, lo: 0xb0, hi: 0xb1},
+	{value: 0x0010, lo: 0xb2, hi: 0xb4},
+	{value: 0x0014, lo: 0xb5, hi: 0xb5},
+	// Block 0x1f, offset 0xfa
+	{value: 0x0014, lo: 0x81, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8d},
+	{value: 0x0010, lo: 0x8f, hi: 0x91},
+	{value: 0x0010, lo: 0x93, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	{value: 0x0010, lo: 0xb5, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x20, offset 0x104
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x85},
+	{value: 0x0014, lo: 0x87, hi: 0x88},
+	{value: 0x0010, lo: 0x89, hi: 0x89},
+	{value: 0x0010, lo: 0x8b, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x90},
+	{value: 0x0010, lo: 0xa0, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0010, lo: 0xb9, hi: 0xb9},
+	{value: 0x0014, lo: 0xba, hi: 0xbf},
+	// Block 0x21, offset 0x110
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x8f, hi: 0x90},
+	{value: 0x0010, lo: 0x93, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	{value: 0x0010, lo: 0xb5, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbe},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x22, offset 0x11b
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x84},
+	{value: 0x0010, lo: 0x87, hi: 0x88},
+	{value: 0x0010, lo: 0x8b, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0014, lo: 0x95, hi: 0x96},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0010, lo: 0x9c, hi: 0x9d},
+	{value: 0x0010, lo: 0x9f, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0010, lo: 0xb1, hi: 0xb1},
+	// Block 0x23, offset 0x127
+	{value: 0x0014, lo: 0x82, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8a},
+	{value: 0x0010, lo: 0x8e, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0x95},
+	{value: 0x0010, lo: 0x99, hi: 0x9a},
+	{value: 0x0010, lo: 0x9c, hi: 0x9c},
+	{value: 0x0010, lo: 0x9e, hi: 0x9f},
+	{value: 0x0010, lo: 0xa3, hi: 0xa4},
+	{value: 0x0010, lo: 0xa8, hi: 0xaa},
+	{value: 0x0010, lo: 0xae, hi: 0xb9},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0x24, offset 0x133
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x82},
+	{value: 0x0010, lo: 0x86, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x90},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	// Block 0x25, offset 0x13b
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x83},
+	{value: 0x0014, lo: 0x84, hi: 0x84},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x8e, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbd},
+	{value: 0x0014, lo: 0xbe, hi: 0xbf},
+	// Block 0x26, offset 0x145
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x84},
+	{value: 0x0014, lo: 0x86, hi: 0x88},
+	{value: 0x0014, lo: 0x8a, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0034, lo: 0x95, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0x9a},
+	{value: 0x0010, lo: 0x9d, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	// Block 0x27, offset 0x150
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x8e, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb3},
+	{value: 0x0010, lo: 0xb5, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbe},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x28, offset 0x15b
+	{value: 0x0010, lo: 0x80, hi: 0x84},
+	{value: 0x0014, lo: 0x86, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x95, hi: 0x96},
+	{value: 0x0010, lo: 0x9d, hi: 0x9e},
+	{value: 0x0010, lo: 0xa0, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0010, lo: 0xb1, hi: 0xb3},
+	// Block 0x29, offset 0x167
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x8c},
+	{value: 0x0010, lo: 0x8e, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0xba},
+	{value: 0x0034, lo: 0xbb, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x2a, offset 0x16d
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x84},
+	{value: 0x0010, lo: 0x86, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x8e, hi: 0x8e},
+	{value: 0x0010, lo: 0x94, hi: 0x97},
+	{value: 0x0010, lo: 0x9f, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0010, lo: 0xba, hi: 0xbf},
+	// Block 0x2b, offset 0x178
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x96},
+	{value: 0x0010, lo: 0x9a, hi: 0xb1},
+	{value: 0x0010, lo: 0xb3, hi: 0xbb},
+	{value: 0x0010, lo: 0xbd, hi: 0xbd},
+	// Block 0x2c, offset 0x17e
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0034, lo: 0x8a, hi: 0x8a},
+	{value: 0x0010, lo: 0x8f, hi: 0x91},
+	{value: 0x0014, lo: 0x92, hi: 0x94},
+	{value: 0x0014, lo: 0x96, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0x9f},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	// Block 0x2d, offset 0x186
+	{value: 0x0014, lo: 0xb1, hi: 0xb1},
+	{value: 0x0014, lo: 0xb4, hi: 0xb7},
+	{value: 0x0034, lo: 0xb8, hi: 0xba},
+	// Block 0x2e, offset 0x189
+	{value: 0x0004, lo: 0x86, hi: 0x86},
+	{value: 0x0014, lo: 0x87, hi: 0x87},
+	{value: 0x0034, lo: 0x88, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8e},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0x2f, offset 0x18e
+	{value: 0x0014, lo: 0xb1, hi: 0xb1},
+	{value: 0x0014, lo: 0xb4, hi: 0xb7},
+	{value: 0x0034, lo: 0xb8, hi: 0xba},
+	{value: 0x0014, lo: 0xbb, hi: 0xbc},
+	// Block 0x30, offset 0x192
+	{value: 0x0004, lo: 0x86, hi: 0x86},
+	{value: 0x0034, lo: 0x88, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8e},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0x31, offset 0x196
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0034, lo: 0x98, hi: 0x99},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	{value: 0x0034, lo: 0xb5, hi: 0xb5},
+	{value: 0x0034, lo: 0xb7, hi: 0xb7},
+	{value: 0x0034, lo: 0xb9, hi: 0xb9},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0x32, offset 0x19d
+	{value: 0x0010, lo: 0x80, hi: 0x87},
+	{value: 0x0010, lo: 0x89, hi: 0xac},
+	{value: 0x0034, lo: 0xb1, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	{value: 0x0014, lo: 0xb5, hi: 0xb9},
+	{value: 0x0034, lo: 0xba, hi: 0xbd},
+	{value: 0x0014, lo: 0xbe, hi: 0xbe},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0x33, offset 0x1a6
+	{value: 0x0034, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0024, lo: 0x82, hi: 0x83},
+	{value: 0x0034, lo: 0x84, hi: 0x84},
+	{value: 0x0024, lo: 0x86, hi: 0x87},
+	{value: 0x0010, lo: 0x88, hi: 0x8c},
+	{value: 0x0014, lo: 0x8d, hi: 0x97},
+	{value: 0x0014, lo: 0x99, hi: 0xbc},
+	// Block 0x34, offset 0x1ae
+	{value: 0x0034, lo: 0x86, hi: 0x86},
+	// Block 0x35, offset 0x1af
+	{value: 0x0010, lo: 0xab, hi: 0xac},
+	{value: 0x0014, lo: 0xad, hi: 0xb0},
+	{value: 0x0010, lo: 0xb1, hi: 0xb1},
+	{value: 0x0014, lo: 0xb2, hi: 0xb6},
+	{value: 0x0034, lo: 0xb7, hi: 0xb7},
+	{value: 0x0010, lo: 0xb8, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbc},
+	{value: 0x0014, lo: 0xbd, hi: 0xbe},
+	// Block 0x36, offset 0x1b8
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x96, hi: 0x97},
+	{value: 0x0014, lo: 0x98, hi: 0x99},
+	{value: 0x0014, lo: 0x9e, hi: 0xa0},
+	{value: 0x0010, lo: 0xa2, hi: 0xa4},
+	{value: 0x0010, lo: 0xa7, hi: 0xad},
+	{value: 0x0014, lo: 0xb1, hi: 0xb4},
+	// Block 0x37, offset 0x1bf
+	{value: 0x0014, lo: 0x82, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x84},
+	{value: 0x0014, lo: 0x85, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x8f, hi: 0x9c},
+	{value: 0x0014, lo: 0x9d, hi: 0x9d},
+	{value: 0x6c53, lo: 0xa0, hi: 0xbf},
+	// Block 0x38, offset 0x1c7
+	{value: 0x0010, lo: 0x80, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0x98},
+	{value: 0x0010, lo: 0x9a, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x39, offset 0x1cd
+	{value: 0x0010, lo: 0x80, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb5},
+	{value: 0x0010, lo: 0xb8, hi: 0xbe},
+	// Block 0x3a, offset 0x1d2
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x82, hi: 0x85},
+	{value: 0x0010, lo: 0x88, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0xbf},
+	// Block 0x3b, offset 0x1d6
+	{value: 0x0010, lo: 0x80, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0x95},
+	{value: 0x0010, lo: 0x98, hi: 0xbf},
+	// Block 0x3c, offset 0x1d9
+	{value: 0x0010, lo: 0x80, hi: 0x9a},
+	{value: 0x0024, lo: 0x9d, hi: 0x9f},
+	// Block 0x3d, offset 0x1db
+	{value: 0x0010, lo: 0x80, hi: 0x8f},
+	{value: 0x7453, lo: 0xa0, hi: 0xaf},
+	{value: 0x7853, lo: 0xb0, hi: 0xbf},
+	// Block 0x3e, offset 0x1de
+	{value: 0x7c53, lo: 0x80, hi: 0x8f},
+	{value: 0x8053, lo: 0x90, hi: 0x9f},
+	{value: 0x7c53, lo: 0xa0, hi: 0xaf},
+	{value: 0x0813, lo: 0xb0, hi: 0xb5},
+	{value: 0x0892, lo: 0xb8, hi: 0xbd},
+	// Block 0x3f, offset 0x1e3
+	{value: 0x0010, lo: 0x81, hi: 0xbf},
+	// Block 0x40, offset 0x1e4
+	{value: 0x0010, lo: 0x80, hi: 0xac},
+	{value: 0x0010, lo: 0xaf, hi: 0xbf},
+	// Block 0x41, offset 0x1e6
+	{value: 0x0010, lo: 0x81, hi: 0x9a},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x42, offset 0x1e8
+	{value: 0x0010, lo: 0x80, hi: 0xaa},
+	{value: 0x0010, lo: 0xae, hi: 0xb8},
+	// Block 0x43, offset 0x1ea
+	{value: 0x0010, lo: 0x80, hi: 0x91},
+	{value: 0x0014, lo: 0x92, hi: 0x93},
+	{value: 0x0034, lo: 0x94, hi: 0x94},
+	{value: 0x0030, lo: 0x95, hi: 0x95},
+	{value: 0x0010, lo: 0x9f, hi: 0xb1},
+	{value: 0x0014, lo: 0xb2, hi: 0xb3},
+	{value: 0x0030, lo: 0xb4, hi: 0xb4},
+	// Block 0x44, offset 0x1f1
+	{value: 0x0010, lo: 0x80, hi: 0x91},
+	{value: 0x0014, lo: 0x92, hi: 0x93},
+	{value: 0x0010, lo: 0xa0, hi: 0xac},
+	{value: 0x0010, lo: 0xae, hi: 0xb0},
+	{value: 0x0014, lo: 0xb2, hi: 0xb3},
+	// Block 0x45, offset 0x1f6
+	{value: 0x0014, lo: 0xb4, hi: 0xb5},
+	{value: 0x0010, lo: 0xb6, hi: 0xb6},
+	{value: 0x0014, lo: 0xb7, hi: 0xbd},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0x46, offset 0x1fa
+	{value: 0x0010, lo: 0x80, hi: 0x85},
+	{value: 0x0014, lo: 0x86, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0x88},
+	{value: 0x0014, lo: 0x89, hi: 0x91},
+	{value: 0x0034, lo: 0x92, hi: 0x92},
+	{value: 0x0014, lo: 0x93, hi: 0x93},
+	{value: 0x0004, lo: 0x97, hi: 0x97},
+	{value: 0x0024, lo: 0x9d, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	// Block 0x47, offset 0x203
+	{value: 0x0014, lo: 0x8b, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x48, offset 0x206
+	{value: 0x0010, lo: 0x80, hi: 0x82},
+	{value: 0x0014, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x84, hi: 0xb8},
+	// Block 0x49, offset 0x209
+	{value: 0x0010, lo: 0x80, hi: 0x84},
+	{value: 0x0014, lo: 0x85, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0xa8},
+	{value: 0x0034, lo: 0xa9, hi: 0xa9},
+	{value: 0x0010, lo: 0xaa, hi: 0xaa},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0x4a, offset 0x20f
+	{value: 0x0010, lo: 0x80, hi: 0xb5},
+	// Block 0x4b, offset 0x210
+	{value: 0x0010, lo: 0x80, hi: 0x9e},
+	{value: 0x0014, lo: 0xa0, hi: 0xa2},
+	{value: 0x0010, lo: 0xa3, hi: 0xa6},
+	{value: 0x0014, lo: 0xa7, hi: 0xa8},
+	{value: 0x0010, lo: 0xa9, hi: 0xab},
+	{value: 0x0010, lo: 0xb0, hi: 0xb1},
+	{value: 0x0014, lo: 0xb2, hi: 0xb2},
+	{value: 0x0010, lo: 0xb3, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xb9},
+	{value: 0x0024, lo: 0xba, hi: 0xba},
+	{value: 0x0034, lo: 0xbb, hi: 0xbb},
+	// Block 0x4c, offset 0x21b
+	{value: 0x0010, lo: 0x86, hi: 0x8f},
+	// Block 0x4d, offset 0x21c
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0x4e, offset 0x21d
+	{value: 0x0010, lo: 0x80, hi: 0x96},
+	{value: 0x0024, lo: 0x97, hi: 0x97},
+	{value: 0x0034, lo: 0x98, hi: 0x98},
+	{value: 0x0010, lo: 0x99, hi: 0x9a},
+	{value: 0x0014, lo: 0x9b, hi: 0x9b},
+	// Block 0x4f, offset 0x222
+	{value: 0x0010, lo: 0x95, hi: 0x95},
+	{value: 0x0014, lo: 0x96, hi: 0x96},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0014, lo: 0x98, hi: 0x9e},
+	{value: 0x0034, lo: 0xa0, hi: 0xa0},
+	{value: 0x0010, lo: 0xa1, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa2},
+	{value: 0x0010, lo: 0xa3, hi: 0xa4},
+	{value: 0x0014, lo: 0xa5, hi: 0xac},
+	{value: 0x0010, lo: 0xad, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb4},
+	{value: 0x0024, lo: 0xb5, hi: 0xbc},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0x50, offset 0x22f
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0004, lo: 0xa7, hi: 0xa7},
+	{value: 0x0024, lo: 0xb0, hi: 0xb4},
+	{value: 0x0034, lo: 0xb5, hi: 0xba},
+	{value: 0x0024, lo: 0xbb, hi: 0xbc},
+	{value: 0x0034, lo: 0xbd, hi: 0xbd},
+	{value: 0x0014, lo: 0xbe, hi: 0xbe},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0x51, offset 0x238
+	{value: 0x0034, lo: 0x80, hi: 0x80},
+	{value: 0x0024, lo: 0x81, hi: 0x82},
+	{value: 0x0034, lo: 0x83, hi: 0x84},
+	{value: 0x0024, lo: 0x85, hi: 0x89},
+	{value: 0x0034, lo: 0x8a, hi: 0x8a},
+	{value: 0x0024, lo: 0x8b, hi: 0x8e},
+	// Block 0x52, offset 0x23e
+	{value: 0x0014, lo: 0x80, hi: 0x83},
+	{value: 0x0010, lo: 0x84, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	{value: 0x0010, lo: 0xb5, hi: 0xb5},
+	{value: 0x0014, lo: 0xb6, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbb},
+	{value: 0x0014, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x53, offset 0x246
+	{value: 0x0010, lo: 0x80, hi: 0x81},
+	{value: 0x0014, lo: 0x82, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x83},
+	{value: 0x0030, lo: 0x84, hi: 0x84},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0024, lo: 0xab, hi: 0xab},
+	{value: 0x0034, lo: 0xac, hi: 0xac},
+	{value: 0x0024, lo: 0xad, hi: 0xb3},
+	// Block 0x54, offset 0x24f
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa5},
+	{value: 0x0010, lo: 0xa6, hi: 0xa7},
+	{value: 0x0014, lo: 0xa8, hi: 0xa9},
+	{value: 0x0030, lo: 0xaa, hi: 0xaa},
+	{value: 0x0034, lo: 0xab, hi: 0xab},
+	{value: 0x0014, lo: 0xac, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xbf},
+	// Block 0x55, offset 0x258
+	{value: 0x0010, lo: 0x80, hi: 0xa5},
+	{value: 0x0034, lo: 0xa6, hi: 0xa6},
+	{value: 0x0010, lo: 0xa7, hi: 0xa7},
+	{value: 0x0014, lo: 0xa8, hi: 0xa9},
+	{value: 0x0010, lo: 0xaa, hi: 0xac},
+	{value: 0x0014, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xae},
+	{value: 0x0014, lo: 0xaf, hi: 0xb1},
+	{value: 0x0030, lo: 0xb2, hi: 0xb3},
+	// Block 0x56, offset 0x261
+	{value: 0x0010, lo: 0x80, hi: 0xab},
+	{value: 0x0014, lo: 0xac, hi: 0xb3},
+	{value: 0x0010, lo: 0xb4, hi: 0xb5},
+	{value: 0x0014, lo: 0xb6, hi: 0xb6},
+	{value: 0x0034, lo: 0xb7, hi: 0xb7},
+	// Block 0x57, offset 0x266
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x8d, hi: 0xb7},
+	{value: 0x0014, lo: 0xb8, hi: 0xbd},
+	// Block 0x58, offset 0x269
+	{value: 0x31ea, lo: 0x80, hi: 0x80},
+	{value: 0x326a, lo: 0x81, hi: 0x81},
+	{value: 0x32ea, lo: 0x82, hi: 0x82},
+	{value: 0x336a, lo: 0x83, hi: 0x83},
+	{value: 0x33ea, lo: 0x84, hi: 0x84},
+	{value: 0x346a, lo: 0x85, hi: 0x85},
+	{value: 0x34ea, lo: 0x86, hi: 0x86},
+	{value: 0x356a, lo: 0x87, hi: 0x87},
+	{value: 0x35ea, lo: 0x88, hi: 0x88},
+	{value: 0x8353, lo: 0x90, hi: 0xba},
+	{value: 0x8353, lo: 0xbd, hi: 0xbf},
+	// Block 0x59, offset 0x274
+	{value: 0x0024, lo: 0x90, hi: 0x92},
+	{value: 0x0034, lo: 0x94, hi: 0x99},
+	{value: 0x0024, lo: 0x9a, hi: 0x9b},
+	{value: 0x0034, lo: 0x9c, hi: 0x9f},
+	{value: 0x0024, lo: 0xa0, hi: 0xa0},
+	{value: 0x0010, lo: 0xa1, hi: 0xa1},
+	{value: 0x0034, lo: 0xa2, hi: 0xa8},
+	{value: 0x0010, lo: 0xa9, hi: 0xac},
+	{value: 0x0034, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xb3},
+	{value: 0x0024, lo: 0xb4, hi: 0xb4},
+	{value: 0x0010, lo: 0xb5, hi: 0xb7},
+	{value: 0x0024, lo: 0xb8, hi: 0xb9},
+	{value: 0x0010, lo: 0xba, hi: 0xba},
+	// Block 0x5a, offset 0x282
+	{value: 0x0012, lo: 0x80, hi: 0xab},
+	{value: 0x0015, lo: 0xac, hi: 0xbf},
+	// Block 0x5b, offset 0x284
+	{value: 0x0015, lo: 0x80, hi: 0xaa},
+	{value: 0x0012, lo: 0xab, hi: 0xb7},
+	{value: 0x0015, lo: 0xb8, hi: 0xb8},
+	{value: 0x8752, lo: 0xb9, hi: 0xb9},
+	{value: 0x0012, lo: 0xba, hi: 0xbc},
+	{value: 0x8b52, lo: 0xbd, hi: 0xbd},
+	{value: 0x0012, lo: 0xbe, hi: 0xbf},
+	// Block 0x5c, offset 0x28b
+	{value: 0x0012, lo: 0x80, hi: 0x8d},
+	{value: 0x8f52, lo: 0x8e, hi: 0x8e},
+	{value: 0x0012, lo: 0x8f, hi: 0x9a},
+	{value: 0x0015, lo: 0x9b, hi: 0xbf},
+	// Block 0x5d, offset 0x28f
+	{value: 0x0024, lo: 0x80, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x82},
+	{value: 0x0024, lo: 0x83, hi: 0x89},
+	{value: 0x0034, lo: 0x8a, hi: 0x8a},
+	{value: 0x0024, lo: 0x8b, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x90},
+	{value: 0x0024, lo: 0x91, hi: 0xb5},
+	{value: 0x0034, lo: 0xb6, hi: 0xba},
+	{value: 0x0024, lo: 0xbb, hi: 0xbb},
+	{value: 0x0034, lo: 0xbc, hi: 0xbd},
+	{value: 0x0024, lo: 0xbe, hi: 0xbe},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0x5e, offset 0x29b
+	{value: 0x0117, lo: 0x80, hi: 0xbf},
+	// Block 0x5f, offset 0x29c
+	{value: 0x0117, lo: 0x80, hi: 0x95},
+	{value: 0x369a, lo: 0x96, hi: 0x96},
+	{value: 0x374a, lo: 0x97, hi: 0x97},
+	{value: 0x37fa, lo: 0x98, hi: 0x98},
+	{value: 0x38aa, lo: 0x99, hi: 0x99},
+	{value: 0x395a, lo: 0x9a, hi: 0x9a},
+	{value: 0x3a0a, lo: 0x9b, hi: 0x9b},
+	{value: 0x0012, lo: 0x9c, hi: 0x9d},
+	{value: 0x3abb, lo: 0x9e, hi: 0x9e},
+	{value: 0x0012, lo: 0x9f, hi: 0x9f},
+	{value: 0x0117, lo: 0xa0, hi: 0xbf},
+	// Block 0x60, offset 0x2a7
+	{value: 0x0812, lo: 0x80, hi: 0x87},
+	{value: 0x0813, lo: 0x88, hi: 0x8f},
+	{value: 0x0812, lo: 0x90, hi: 0x95},
+	{value: 0x0813, lo: 0x98, hi: 0x9d},
+	{value: 0x0812, lo: 0xa0, hi: 0xa7},
+	{value: 0x0813, lo: 0xa8, hi: 0xaf},
+	{value: 0x0812, lo: 0xb0, hi: 0xb7},
+	{value: 0x0813, lo: 0xb8, hi: 0xbf},
+	// Block 0x61, offset 0x2af
+	{value: 0x0004, lo: 0x8b, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8f},
+	{value: 0x0054, lo: 0x98, hi: 0x99},
+	{value: 0x0054, lo: 0xa4, hi: 0xa4},
+	{value: 0x0054, lo: 0xa7, hi: 0xa7},
+	{value: 0x0014, lo: 0xaa, hi: 0xae},
+	{value: 0x0010, lo: 0xaf, hi: 0xaf},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0x62, offset 0x2b7
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x94, hi: 0x94},
+	{value: 0x0014, lo: 0xa0, hi: 0xa4},
+	{value: 0x0014, lo: 0xa6, hi: 0xaf},
+	{value: 0x0015, lo: 0xb1, hi: 0xb1},
+	{value: 0x0015, lo: 0xbf, hi: 0xbf},
+	// Block 0x63, offset 0x2bd
+	{value: 0x0015, lo: 0x90, hi: 0x9c},
+	// Block 0x64, offset 0x2be
+	{value: 0x0024, lo: 0x90, hi: 0x91},
+	{value: 0x0034, lo: 0x92, hi: 0x93},
+	{value: 0x0024, lo: 0x94, hi: 0x97},
+	{value: 0x0034, lo: 0x98, hi: 0x9a},
+	{value: 0x0024, lo: 0x9b, hi: 0x9c},
+	{value: 0x0014, lo: 0x9d, hi: 0xa0},
+	{value: 0x0024, lo: 0xa1, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa4},
+	{value: 0x0034, lo: 0xa5, hi: 0xa6},
+	{value: 0x0024, lo: 0xa7, hi: 0xa7},
+	{value: 0x0034, lo: 0xa8, hi: 0xa8},
+	{value: 0x0024, lo: 0xa9, hi: 0xa9},
+	{value: 0x0034, lo: 0xaa, hi: 0xaf},
+	{value: 0x0024, lo: 0xb0, hi: 0xb0},
+	// Block 0x65, offset 0x2cc
+	{value: 0x0016, lo: 0x85, hi: 0x86},
+	{value: 0x0012, lo: 0x87, hi: 0x89},
+	{value: 0xa452, lo: 0x8e, hi: 0x8e},
+	{value: 0x1013, lo: 0xa0, hi: 0xaf},
+	{value: 0x1012, lo: 0xb0, hi: 0xbf},
+	// Block 0x66, offset 0x2d1
+	{value: 0x0010, lo: 0x80, hi: 0x82},
+	{value: 0x0716, lo: 0x83, hi: 0x84},
+	{value: 0x0010, lo: 0x85, hi: 0x88},
+	// Block 0x67, offset 0x2d4
+	{value: 0xa753, lo: 0xb6, hi: 0xb7},
+	{value: 0xaa53, lo: 0xb8, hi: 0xb9},
+	{value: 0xad53, lo: 0xba, hi: 0xbb},
+	{value: 0xaa53, lo: 0xbc, hi: 0xbd},
+	{value: 0xa753, lo: 0xbe, hi: 0xbf},
+	// Block 0x68, offset 0x2d9
+	{value: 0x3013, lo: 0x80, hi: 0x8f},
+	{value: 0x6553, lo: 0x90, hi: 0x9f},
+	{value: 0xb053, lo: 0xa0, hi: 0xaf},
+	{value: 0x3012, lo: 0xb0, hi: 0xbf},
+	// Block 0x69, offset 0x2dd
+	{value: 0x0117, lo: 0x80, hi: 0xa3},
+	{value: 0x0012, lo: 0xa4, hi: 0xa4},
+	{value: 0x0716, lo: 0xab, hi: 0xac},
+	{value: 0x0316, lo: 0xad, hi: 0xae},
+	{value: 0x0024, lo: 0xaf, hi: 0xb1},
+	{value: 0x0117, lo: 0xb2, hi: 0xb3},
+	// Block 0x6a, offset 0x2e3
+	{value: 0x6c52, lo: 0x80, hi: 0x9f},
+	{value: 0x7052, lo: 0xa0, hi: 0xa5},
+	{value: 0x7052, lo: 0xa7, hi: 0xa7},
+	{value: 0x7052, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0x6b, offset 0x2e8
+	{value: 0x0010, lo: 0x80, hi: 0xa7},
+	{value: 0x0014, lo: 0xaf, hi: 0xaf},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0x6c, offset 0x2eb
+	{value: 0x0010, lo: 0x80, hi: 0x96},
+	{value: 0x0010, lo: 0xa0, hi: 0xa6},
+	{value: 0x0010, lo: 0xa8, hi: 0xae},
+	{value: 0x0010, lo: 0xb0, hi: 0xb6},
+	{value: 0x0010, lo: 0xb8, hi: 0xbe},
+	// Block 0x6d, offset 0x2f0
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0010, lo: 0x88, hi: 0x8e},
+	{value: 0x0010, lo: 0x90, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0x9e},
+	{value: 0x0024, lo: 0xa0, hi: 0xbf},
+	// Block 0x6e, offset 0x2f5
+	{value: 0x0014, lo: 0xaf, hi: 0xaf},
+	// Block 0x6f, offset 0x2f6
+	{value: 0x0014, lo: 0x85, hi: 0x85},
+	{value: 0x0034, lo: 0xaa, hi: 0xad},
+	{value: 0x0030, lo: 0xae, hi: 0xaf},
+	{value: 0x0004, lo: 0xb1, hi: 0xb5},
+	{value: 0x0014, lo: 0xbb, hi: 0xbb},
+	{value: 0x0010, lo: 0xbc, hi: 0xbc},
+	// Block 0x70, offset 0x2fc
+	{value: 0x0034, lo: 0x99, hi: 0x9a},
+	{value: 0x0004, lo: 0x9b, hi: 0x9e},
+	// Block 0x71, offset 0x2fe
+	{value: 0x0004, lo: 0xbc, hi: 0xbe},
+	// Block 0x72, offset 0x2ff
+	{value: 0x0010, lo: 0x85, hi: 0xaf},
+	{value: 0x0010, lo: 0xb1, hi: 0xbf},
+	// Block 0x73, offset 0x301
+	{value: 0x0010, lo: 0x80, hi: 0x8e},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x74, offset 0x303
+	{value: 0x0010, lo: 0x80, hi: 0x94},
+	{value: 0x0014, lo: 0x95, hi: 0x95},
+	{value: 0x0010, lo: 0x96, hi: 0xbf},
+	// Block 0x75, offset 0x306
+	{value: 0x0010, lo: 0x80, hi: 0x8c},
+	// Block 0x76, offset 0x307
+	{value: 0x0010, lo: 0x90, hi: 0xb7},
+	{value: 0x0014, lo: 0xb8, hi: 0xbd},
+	// Block 0x77, offset 0x309
+	{value: 0x0010, lo: 0x80, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8c},
+	{value: 0x0010, lo: 0x90, hi: 0xab},
+	// Block 0x78, offset 0x30c
+	{value: 0x0117, lo: 0x80, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xae},
+	{value: 0x0024, lo: 0xaf, hi: 0xaf},
+	{value: 0x0014, lo: 0xb0, hi: 0xb2},
+	{value: 0x0024, lo: 0xb4, hi: 0xbd},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x79, offset 0x312
+	{value: 0x0117, lo: 0x80, hi: 0x9b},
+	{value: 0x0015, lo: 0x9c, hi: 0x9d},
+	{value: 0x0024, lo: 0x9e, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x7a, offset 0x316
+	{value: 0x0010, lo: 0x80, hi: 0xaf},
+	{value: 0x0024, lo: 0xb0, hi: 0xb1},
+	// Block 0x7b, offset 0x318
+	{value: 0x0004, lo: 0x80, hi: 0x87},
+	{value: 0x0014, lo: 0x88, hi: 0xa1},
+	{value: 0x0117, lo: 0xa2, hi: 0xaf},
+	{value: 0x0012, lo: 0xb0, hi: 0xb1},
+	{value: 0x0117, lo: 0xb2, hi: 0xbf},
+	// Block 0x7c, offset 0x31d
+	{value: 0x0117, lo: 0x80, hi: 0xaf},
+	{value: 0x0015, lo: 0xb0, hi: 0xb0},
+	{value: 0x0012, lo: 0xb1, hi: 0xb8},
+	{value: 0x0316, lo: 0xb9, hi: 0xba},
+	{value: 0x0716, lo: 0xbb, hi: 0xbc},
+	{value: 0x8753, lo: 0xbd, hi: 0xbd},
+	{value: 0x0117, lo: 0xbe, hi: 0xbf},
+	// Block 0x7d, offset 0x324
+	{value: 0x0117, lo: 0x80, hi: 0x83},
+	{value: 0x6553, lo: 0x84, hi: 0x84},
+	{value: 0x908b, lo: 0x85, hi: 0x85},
+	{value: 0x8f53, lo: 0x86, hi: 0x86},
+	{value: 0x0f16, lo: 0x87, hi: 0x88},
+	{value: 0x0316, lo: 0x89, hi: 0x8a},
+	{value: 0x0117, lo: 0x90, hi: 0x91},
+	{value: 0x0012, lo: 0x93, hi: 0x93},
+	{value: 0x0012, lo: 0x95, hi: 0x95},
+	{value: 0x0117, lo: 0x96, hi: 0x99},
+	{value: 0x0015, lo: 0xb2, hi: 0xb4},
+	{value: 0x0316, lo: 0xb5, hi: 0xb6},
+	{value: 0x0010, lo: 0xb7, hi: 0xb7},
+	{value: 0x0015, lo: 0xb8, hi: 0xb9},
+	{value: 0x0012, lo: 0xba, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbf},
+	// Block 0x7e, offset 0x334
+	{value: 0x0010, lo: 0x80, hi: 0x81},
+	{value: 0x0014, lo: 0x82, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x85},
+	{value: 0x0034, lo: 0x86, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0x8a},
+	{value: 0x0014, lo: 0x8b, hi: 0x8b},
+	{value: 0x0010, lo: 0x8c, hi: 0xa4},
+	{value: 0x0014, lo: 0xa5, hi: 0xa6},
+	{value: 0x0010, lo: 0xa7, hi: 0xa7},
+	{value: 0x0034, lo: 0xac, hi: 0xac},
+	// Block 0x7f, offset 0x33e
+	{value: 0x0010, lo: 0x80, hi: 0xb3},
+	// Block 0x80, offset 0x33f
+	{value: 0x0010, lo: 0x80, hi: 0x83},
+	{value: 0x0034, lo: 0x84, hi: 0x84},
+	{value: 0x0014, lo: 0x85, hi: 0x85},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0024, lo: 0xa0, hi: 0xb1},
+	{value: 0x0010, lo: 0xb2, hi: 0xb7},
+	{value: 0x0010, lo: 0xbb, hi: 0xbb},
+	{value: 0x0010, lo: 0xbd, hi: 0xbe},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x81, offset 0x348
+	{value: 0x0010, lo: 0x80, hi: 0xa5},
+	{value: 0x0014, lo: 0xa6, hi: 0xaa},
+	{value: 0x0034, lo: 0xab, hi: 0xad},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0x82, offset 0x34c
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0014, lo: 0x87, hi: 0x91},
+	{value: 0x0010, lo: 0x92, hi: 0x92},
+	{value: 0x0030, lo: 0x93, hi: 0x93},
+	{value: 0x0010, lo: 0xa0, hi: 0xbc},
+	// Block 0x83, offset 0x351
+	{value: 0x0014, lo: 0x80, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0xb2},
+	{value: 0x0034, lo: 0xb3, hi: 0xb3},
+	{value: 0x0010, lo: 0xb4, hi: 0xb5},
+	{value: 0x0014, lo: 0xb6, hi: 0xb9},
+	{value: 0x0010, lo: 0xba, hi: 0xbb},
+	{value: 0x0014, lo: 0xbc, hi: 0xbd},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0x84, offset 0x359
+	{value: 0x0030, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x8f, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0014, lo: 0xa5, hi: 0xa5},
+	{value: 0x0004, lo: 0xa6, hi: 0xa6},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x85, offset 0x35f
+	{value: 0x0010, lo: 0x80, hi: 0xa8},
+	{value: 0x0014, lo: 0xa9, hi: 0xae},
+	{value: 0x0010, lo: 0xaf, hi: 0xb0},
+	{value: 0x0014, lo: 0xb1, hi: 0xb2},
+	{value: 0x0010, lo: 0xb3, hi: 0xb4},
+	{value: 0x0014, lo: 0xb5, hi: 0xb6},
+	// Block 0x86, offset 0x365
+	{value: 0x0010, lo: 0x80, hi: 0x82},
+	{value: 0x0014, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x84, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8c},
+	{value: 0x0010, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0004, lo: 0xb0, hi: 0xb0},
+	{value: 0x0010, lo: 0xbb, hi: 0xbb},
+	{value: 0x0014, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbd},
+	// Block 0x87, offset 0x36f
+	{value: 0x0024, lo: 0xb0, hi: 0xb0},
+	{value: 0x0024, lo: 0xb2, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	{value: 0x0024, lo: 0xb7, hi: 0xb8},
+	{value: 0x0024, lo: 0xbe, hi: 0xbf},
+	// Block 0x88, offset 0x374
+	{value: 0x0024, lo: 0x81, hi: 0x81},
+	{value: 0x0004, lo: 0x9d, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xab},
+	{value: 0x0014, lo: 0xac, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xaf},
+	{value: 0x0010, lo: 0xb2, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb4},
+	{value: 0x0010, lo: 0xb5, hi: 0xb5},
+	{value: 0x0034, lo: 0xb6, hi: 0xb6},
+	// Block 0x89, offset 0x37d
+	{value: 0x0010, lo: 0x81, hi: 0x86},
+	{value: 0x0010, lo: 0x89, hi: 0x8e},
+	{value: 0x0010, lo: 0x91, hi: 0x96},
+	{value: 0x0010, lo: 0xa0, hi: 0xa6},
+	{value: 0x0010, lo: 0xa8, hi: 0xae},
+	{value: 0x0012, lo: 0xb0, hi: 0xbf},
+	// Block 0x8a, offset 0x383
+	{value: 0x0012, lo: 0x80, hi: 0x92},
+	{value: 0xb352, lo: 0x93, hi: 0x93},
+	{value: 0x0012, lo: 0x94, hi: 0x9a},
+	{value: 0x0014, lo: 0x9b, hi: 0x9b},
+	{value: 0x0015, lo: 0x9c, hi: 0x9f},
+	{value: 0x0012, lo: 0xa0, hi: 0xa8},
+	{value: 0x0015, lo: 0xa9, hi: 0xa9},
+	{value: 0x0004, lo: 0xaa, hi: 0xab},
+	{value: 0x74d2, lo: 0xb0, hi: 0xbf},
+	// Block 0x8b, offset 0x38c
+	{value: 0x78d2, lo: 0x80, hi: 0x8f},
+	{value: 0x7cd2, lo: 0x90, hi: 0x9f},
+	{value: 0x80d2, lo: 0xa0, hi: 0xaf},
+	{value: 0x7cd2, lo: 0xb0, hi: 0xbf},
+	// Block 0x8c, offset 0x390
+	{value: 0x0010, lo: 0x80, hi: 0xa4},
+	{value: 0x0014, lo: 0xa5, hi: 0xa5},
+	{value: 0x0010, lo: 0xa6, hi: 0xa7},
+	{value: 0x0014, lo: 0xa8, hi: 0xa8},
+	{value: 0x0010, lo: 0xa9, hi: 0xaa},
+	{value: 0x0010, lo: 0xac, hi: 0xac},
+	{value: 0x0034, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x8d, offset 0x398
+	{value: 0x0010, lo: 0x80, hi: 0xa3},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0x8e, offset 0x39a
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0010, lo: 0x8b, hi: 0xbb},
+	// Block 0x8f, offset 0x39c
+	{value: 0x0010, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x83, hi: 0x84},
+	{value: 0x0010, lo: 0x86, hi: 0xbf},
+	// Block 0x90, offset 0x39f
+	{value: 0x0010, lo: 0x80, hi: 0xb1},
+	{value: 0x0004, lo: 0xb2, hi: 0xbf},
+	// Block 0x91, offset 0x3a1
+	{value: 0x0004, lo: 0x80, hi: 0x82},
+	{value: 0x0010, lo: 0x93, hi: 0xbf},
+	// Block 0x92, offset 0x3a3
+	{value: 0x0010, lo: 0x80, hi: 0xbd},
+	// Block 0x93, offset 0x3a4
+	{value: 0x0010, lo: 0x90, hi: 0xbf},
+	// Block 0x94, offset 0x3a5
+	{value: 0x0010, lo: 0x80, hi: 0x8f},
+	{value: 0x0010, lo: 0x92, hi: 0xbf},
+	// Block 0x95, offset 0x3a7
+	{value: 0x0010, lo: 0x80, hi: 0x87},
+	{value: 0x0010, lo: 0xb0, hi: 0xbb},
+	// Block 0x96, offset 0x3a9
+	{value: 0x0014, lo: 0x80, hi: 0x8f},
+	{value: 0x0054, lo: 0x93, hi: 0x93},
+	{value: 0x0024, lo: 0xa0, hi: 0xa6},
+	{value: 0x0034, lo: 0xa7, hi: 0xad},
+	{value: 0x0024, lo: 0xae, hi: 0xaf},
+	{value: 0x0010, lo: 0xb3, hi: 0xb4},
+	// Block 0x97, offset 0x3af
+	{value: 0x0010, lo: 0x8d, hi: 0x8f},
+	{value: 0x0054, lo: 0x92, hi: 0x92},
+	{value: 0x0054, lo: 0x95, hi: 0x95},
+	{value: 0x0010, lo: 0xb0, hi: 0xb4},
+	{value: 0x0010, lo: 0xb6, hi: 0xbf},
+	// Block 0x98, offset 0x3b4
+	{value: 0x0010, lo: 0x80, hi: 0xbc},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x99, offset 0x3b6
+	{value: 0x0054, lo: 0x87, hi: 0x87},
+	{value: 0x0054, lo: 0x8e, hi: 0x8e},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0054, lo: 0x9a, hi: 0x9a},
+	{value: 0x5f53, lo: 0xa1, hi: 0xba},
+	{value: 0x0004, lo: 0xbe, hi: 0xbe},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0x9a, offset 0x3bd
+	{value: 0x0004, lo: 0x80, hi: 0x80},
+	{value: 0x5f52, lo: 0x81, hi: 0x9a},
+	{value: 0x0004, lo: 0xb0, hi: 0xb0},
+	// Block 0x9b, offset 0x3c0
+	{value: 0x0014, lo: 0x9e, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xbe},
+	// Block 0x9c, offset 0x3c2
+	{value: 0x0010, lo: 0x82, hi: 0x87},
+	{value: 0x0010, lo: 0x8a, hi: 0x8f},
+	{value: 0x0010, lo: 0x92, hi: 0x97},
+	{value: 0x0010, lo: 0x9a, hi: 0x9c},
+	{value: 0x0004, lo: 0xa3, hi: 0xa3},
+	{value: 0x0014, lo: 0xb9, hi: 0xbb},
+	// Block 0x9d, offset 0x3c8
+	{value: 0x0010, lo: 0x80, hi: 0x8b},
+	{value: 0x0010, lo: 0x8d, hi: 0xa6},
+	{value: 0x0010, lo: 0xa8, hi: 0xba},
+	{value: 0x0010, lo: 0xbc, hi: 0xbd},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0x9e, offset 0x3cd
+	{value: 0x0010, lo: 0x80, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x9d},
+	// Block 0x9f, offset 0x3cf
+	{value: 0x0010, lo: 0x80, hi: 0xba},
+	// Block 0xa0, offset 0x3d0
+	{value: 0x0010, lo: 0x80, hi: 0xb4},
+	// Block 0xa1, offset 0x3d1
+	{value: 0x0034, lo: 0xbd, hi: 0xbd},
+	// Block 0xa2, offset 0x3d2
+	{value: 0x0010, lo: 0x80, hi: 0x9c},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0xa3, offset 0x3d4
+	{value: 0x0010, lo: 0x80, hi: 0x90},
+	{value: 0x0034, lo: 0xa0, hi: 0xa0},
+	// Block 0xa4, offset 0x3d6
+	{value: 0x0010, lo: 0x80, hi: 0x9f},
+	{value: 0x0010, lo: 0xad, hi: 0xbf},
+	// Block 0xa5, offset 0x3d8
+	{value: 0x0010, lo: 0x80, hi: 0x8a},
+	{value: 0x0010, lo: 0x90, hi: 0xb5},
+	{value: 0x0024, lo: 0xb6, hi: 0xba},
+	// Block 0xa6, offset 0x3db
+	{value: 0x0010, lo: 0x80, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0xa7, offset 0x3dd
+	{value: 0x0010, lo: 0x80, hi: 0x83},
+	{value: 0x0010, lo: 0x88, hi: 0x8f},
+	{value: 0x0010, lo: 0x91, hi: 0x95},
+	// Block 0xa8, offset 0x3e0
+	{value: 0x2813, lo: 0x80, hi: 0x87},
+	{value: 0x3813, lo: 0x88, hi: 0x8f},
+	{value: 0x2813, lo: 0x90, hi: 0x97},
+	{value: 0xb653, lo: 0x98, hi: 0x9f},
+	{value: 0xb953, lo: 0xa0, hi: 0xa7},
+	{value: 0x2812, lo: 0xa8, hi: 0xaf},
+	{value: 0x3812, lo: 0xb0, hi: 0xb7},
+	{value: 0x2812, lo: 0xb8, hi: 0xbf},
+	// Block 0xa9, offset 0x3e8
+	{value: 0xb652, lo: 0x80, hi: 0x87},
+	{value: 0xb952, lo: 0x88, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0xbf},
+	// Block 0xaa, offset 0x3eb
+	{value: 0x0010, lo: 0x80, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	{value: 0xb953, lo: 0xb0, hi: 0xb7},
+	{value: 0xb653, lo: 0xb8, hi: 0xbf},
+	// Block 0xab, offset 0x3ef
+	{value: 0x2813, lo: 0x80, hi: 0x87},
+	{value: 0x3813, lo: 0x88, hi: 0x8f},
+	{value: 0x2813, lo: 0x90, hi: 0x93},
+	{value: 0xb952, lo: 0x98, hi: 0x9f},
+	{value: 0xb652, lo: 0xa0, hi: 0xa7},
+	{value: 0x2812, lo: 0xa8, hi: 0xaf},
+	{value: 0x3812, lo: 0xb0, hi: 0xb7},
+	{value: 0x2812, lo: 0xb8, hi: 0xbb},
+	// Block 0xac, offset 0x3f7
+	{value: 0x0010, lo: 0x80, hi: 0xa7},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xad, offset 0x3f9
+	{value: 0x0010, lo: 0x80, hi: 0xa3},
+	{value: 0xbc53, lo: 0xb0, hi: 0xb0},
+	{value: 0xbf53, lo: 0xb1, hi: 0xb1},
+	{value: 0xc253, lo: 0xb2, hi: 0xb2},
+	{value: 0xbf53, lo: 0xb3, hi: 0xb3},
+	{value: 0xc553, lo: 0xb4, hi: 0xb4},
+	{value: 0xbf53, lo: 0xb5, hi: 0xb5},
+	{value: 0xc253, lo: 0xb6, hi: 0xb6},
+	{value: 0xbf53, lo: 0xb7, hi: 0xb7},
+	{value: 0xbc53, lo: 0xb8, hi: 0xb8},
+	{value: 0xc853, lo: 0xb9, hi: 0xb9},
+	{value: 0xcb53, lo: 0xba, hi: 0xba},
+	{value: 0xce53, lo: 0xbc, hi: 0xbc},
+	{value: 0xc853, lo: 0xbd, hi: 0xbd},
+	{value: 0xcb53, lo: 0xbe, hi: 0xbe},
+	{value: 0xc853, lo: 0xbf, hi: 0xbf},
+	// Block 0xae, offset 0x409
+	{value: 0x0010, lo: 0x80, hi: 0xb6},
+	// Block 0xaf, offset 0x40a
+	{value: 0x0010, lo: 0x80, hi: 0x95},
+	{value: 0x0010, lo: 0xa0, hi: 0xa7},
+	// Block 0xb0, offset 0x40c
+	{value: 0x0015, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x82},
+	{value: 0x0015, lo: 0x83, hi: 0x85},
+	{value: 0x0015, lo: 0x87, hi: 0xb0},
+	{value: 0x0015, lo: 0xb2, hi: 0xba},
+	// Block 0xb1, offset 0x411
+	{value: 0x0010, lo: 0x80, hi: 0x85},
+	{value: 0x0010, lo: 0x88, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0xb5},
+	{value: 0x0010, lo: 0xb7, hi: 0xb8},
+	{value: 0x0010, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0xb2, offset 0x417
+	{value: 0x0010, lo: 0x80, hi: 0x95},
+	{value: 0x0010, lo: 0xa0, hi: 0xb6},
+	// Block 0xb3, offset 0x419
+	{value: 0x0010, lo: 0x80, hi: 0x9e},
+	// Block 0xb4, offset 0x41a
+	{value: 0x0010, lo: 0xa0, hi: 0xb2},
+	{value: 0x0010, lo: 0xb4, hi: 0xb5},
+	// Block 0xb5, offset 0x41c
+	{value: 0x0010, lo: 0x80, hi: 0x95},
+	{value: 0x0010, lo: 0xa0, hi: 0xb9},
+	// Block 0xb6, offset 0x41e
+	{value: 0x0010, lo: 0x80, hi: 0xb7},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0xb7, offset 0x420
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x83},
+	{value: 0x0014, lo: 0x85, hi: 0x86},
+	{value: 0x0014, lo: 0x8c, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0014, lo: 0x8e, hi: 0x8e},
+	{value: 0x0024, lo: 0x8f, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0x93},
+	{value: 0x0010, lo: 0x95, hi: 0x97},
+	{value: 0x0010, lo: 0x99, hi: 0xb5},
+	{value: 0x0024, lo: 0xb8, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xba},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0xb8, offset 0x42d
+	{value: 0x0010, lo: 0xa0, hi: 0xbc},
+	// Block 0xb9, offset 0x42e
+	{value: 0x0010, lo: 0x80, hi: 0x9c},
+	// Block 0xba, offset 0x42f
+	{value: 0x0010, lo: 0x80, hi: 0x87},
+	{value: 0x0010, lo: 0x89, hi: 0xa4},
+	{value: 0x0024, lo: 0xa5, hi: 0xa5},
+	{value: 0x0034, lo: 0xa6, hi: 0xa6},
+	// Block 0xbb, offset 0x433
+	{value: 0x0010, lo: 0x80, hi: 0x95},
+	{value: 0x0010, lo: 0xa0, hi: 0xb2},
+	// Block 0xbc, offset 0x435
+	{value: 0x0010, lo: 0x80, hi: 0x91},
+	// Block 0xbd, offset 0x436
+	{value: 0x0010, lo: 0x80, hi: 0x88},
+	// Block 0xbe, offset 0x437
+	{value: 0x5653, lo: 0x80, hi: 0xb2},
+	// Block 0xbf, offset 0x438
+	{value: 0x5652, lo: 0x80, hi: 0xb2},
+	// Block 0xc0, offset 0x439
+	{value: 0x0010, lo: 0x80, hi: 0xa3},
+	{value: 0x0024, lo: 0xa4, hi: 0xa7},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0xc1, offset 0x43c
+	{value: 0x0010, lo: 0x80, hi: 0xa9},
+	{value: 0x0024, lo: 0xab, hi: 0xac},
+	{value: 0x0010, lo: 0xb0, hi: 0xb1},
+	// Block 0xc2, offset 0x43f
+	{value: 0x0034, lo: 0xbd, hi: 0xbf},
+	// Block 0xc3, offset 0x440
+	{value: 0x0010, lo: 0x80, hi: 0x9c},
+	{value: 0x0010, lo: 0xa7, hi: 0xa7},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xc4, offset 0x443
+	{value: 0x0010, lo: 0x80, hi: 0x85},
+	{value: 0x0034, lo: 0x86, hi: 0x87},
+	{value: 0x0024, lo: 0x88, hi: 0x8a},
+	{value: 0x0034, lo: 0x8b, hi: 0x8b},
+	{value: 0x0024, lo: 0x8c, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x90},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xc5, offset 0x44a
+	{value: 0x0010, lo: 0x80, hi: 0x81},
+	{value: 0x0024, lo: 0x82, hi: 0x82},
+	{value: 0x0034, lo: 0x83, hi: 0x83},
+	{value: 0x0024, lo: 0x84, hi: 0x84},
+	{value: 0x0034, lo: 0x85, hi: 0x85},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xc6, offset 0x450
+	{value: 0x0010, lo: 0x80, hi: 0x84},
+	{value: 0x0010, lo: 0xa0, hi: 0xb6},
+	// Block 0xc7, offset 0x452
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0xb7},
+	{value: 0x0014, lo: 0xb8, hi: 0xbf},
+	// Block 0xc8, offset 0x456
+	{value: 0x0014, lo: 0x80, hi: 0x85},
+	{value: 0x0034, lo: 0x86, hi: 0x86},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0034, lo: 0xb0, hi: 0xb0},
+	{value: 0x0010, lo: 0xb1, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb4},
+	{value: 0x0010, lo: 0xb5, hi: 0xb5},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0xc9, offset 0x45e
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb6},
+	{value: 0x0010, lo: 0xb7, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xba},
+	{value: 0x0014, lo: 0xbd, hi: 0xbd},
+	// Block 0xca, offset 0x464
+	{value: 0x0014, lo: 0x82, hi: 0x82},
+	{value: 0x0014, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0xa8},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0xcb, offset 0x468
+	{value: 0x0024, lo: 0x80, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0xa6},
+	{value: 0x0014, lo: 0xa7, hi: 0xab},
+	{value: 0x0010, lo: 0xac, hi: 0xac},
+	{value: 0x0014, lo: 0xad, hi: 0xb2},
+	{value: 0x0034, lo: 0xb3, hi: 0xb4},
+	{value: 0x0010, lo: 0xb6, hi: 0xbf},
+	// Block 0xcc, offset 0x46f
+	{value: 0x0010, lo: 0x84, hi: 0x87},
+	{value: 0x0010, lo: 0x90, hi: 0xb2},
+	{value: 0x0034, lo: 0xb3, hi: 0xb3},
+	{value: 0x0010, lo: 0xb6, hi: 0xb6},
+	// Block 0xcd, offset 0x473
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0xb5},
+	{value: 0x0014, lo: 0xb6, hi: 0xbe},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0xce, offset 0x477
+	{value: 0x0030, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x84},
+	{value: 0x0014, lo: 0x89, hi: 0x89},
+	{value: 0x0034, lo: 0x8a, hi: 0x8a},
+	{value: 0x0014, lo: 0x8b, hi: 0x8c},
+	{value: 0x0010, lo: 0x8e, hi: 0x8e},
+	{value: 0x0014, lo: 0x8f, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0x9a},
+	{value: 0x0010, lo: 0x9c, hi: 0x9c},
+	// Block 0xcf, offset 0x480
+	{value: 0x0010, lo: 0x80, hi: 0x91},
+	{value: 0x0010, lo: 0x93, hi: 0xae},
+	{value: 0x0014, lo: 0xaf, hi: 0xb1},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	{value: 0x0014, lo: 0xb4, hi: 0xb4},
+	{value: 0x0030, lo: 0xb5, hi: 0xb5},
+	{value: 0x0034, lo: 0xb6, hi: 0xb6},
+	{value: 0x0014, lo: 0xb7, hi: 0xb7},
+	{value: 0x0014, lo: 0xbe, hi: 0xbe},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0xd0, offset 0x48a
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	// Block 0xd1, offset 0x48c
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0010, lo: 0x88, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8d},
+	{value: 0x0010, lo: 0x8f, hi: 0x9d},
+	{value: 0x0010, lo: 0x9f, hi: 0xa8},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xd2, offset 0x492
+	{value: 0x0010, lo: 0x80, hi: 0x9e},
+	{value: 0x0014, lo: 0x9f, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xa2},
+	{value: 0x0014, lo: 0xa3, hi: 0xa8},
+	{value: 0x0034, lo: 0xa9, hi: 0xaa},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0xd3, offset 0x498
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x8f, hi: 0x90},
+	{value: 0x0010, lo: 0x93, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	{value: 0x0010, lo: 0xb5, hi: 0xb9},
+	{value: 0x0034, lo: 0xbb, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0xd4, offset 0x4a2
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x84},
+	{value: 0x0010, lo: 0x87, hi: 0x88},
+	{value: 0x0010, lo: 0x8b, hi: 0x8c},
+	{value: 0x0030, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x90},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0010, lo: 0x9d, hi: 0xa3},
+	{value: 0x0024, lo: 0xa6, hi: 0xac},
+	{value: 0x0024, lo: 0xb0, hi: 0xb4},
+	// Block 0xd5, offset 0x4ac
+	{value: 0x0010, lo: 0x80, hi: 0xb7},
+	{value: 0x0014, lo: 0xb8, hi: 0xbf},
+	// Block 0xd6, offset 0x4ae
+	{value: 0x0010, lo: 0x80, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x82},
+	{value: 0x0014, lo: 0x83, hi: 0x84},
+	{value: 0x0010, lo: 0x85, hi: 0x85},
+	{value: 0x0034, lo: 0x86, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0x8a},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0024, lo: 0x9e, hi: 0x9e},
+	{value: 0x0010, lo: 0x9f, hi: 0xa1},
+	// Block 0xd7, offset 0x4b7
+	{value: 0x0010, lo: 0x80, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb8},
+	{value: 0x0010, lo: 0xb9, hi: 0xb9},
+	{value: 0x0014, lo: 0xba, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbe},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0xd8, offset 0x4bd
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x84, hi: 0x85},
+	{value: 0x0010, lo: 0x87, hi: 0x87},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0xd9, offset 0x4c3
+	{value: 0x0010, lo: 0x80, hi: 0xb1},
+	{value: 0x0014, lo: 0xb2, hi: 0xb5},
+	{value: 0x0010, lo: 0xb8, hi: 0xbb},
+	{value: 0x0014, lo: 0xbc, hi: 0xbd},
+	{value: 0x0010, lo: 0xbe, hi: 0xbe},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0xda, offset 0x4c9
+	{value: 0x0034, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x98, hi: 0x9b},
+	{value: 0x0014, lo: 0x9c, hi: 0x9d},
+	// Block 0xdb, offset 0x4cc
+	{value: 0x0010, lo: 0x80, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbc},
+	{value: 0x0014, lo: 0xbd, hi: 0xbd},
+	{value: 0x0010, lo: 0xbe, hi: 0xbe},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0xdc, offset 0x4d2
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x84, hi: 0x84},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0xdd, offset 0x4d5
+	{value: 0x0010, lo: 0x80, hi: 0xaa},
+	{value: 0x0014, lo: 0xab, hi: 0xab},
+	{value: 0x0010, lo: 0xac, hi: 0xac},
+	{value: 0x0014, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xaf},
+	{value: 0x0014, lo: 0xb0, hi: 0xb5},
+	{value: 0x0030, lo: 0xb6, hi: 0xb6},
+	{value: 0x0034, lo: 0xb7, hi: 0xb7},
+	{value: 0x0010, lo: 0xb8, hi: 0xb8},
+	// Block 0xde, offset 0x4de
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	// Block 0xdf, offset 0x4df
+	{value: 0x0014, lo: 0x9d, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa5},
+	{value: 0x0010, lo: 0xa6, hi: 0xa6},
+	{value: 0x0014, lo: 0xa7, hi: 0xaa},
+	{value: 0x0034, lo: 0xab, hi: 0xab},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0xe0, offset 0x4e6
+	{value: 0x0010, lo: 0x80, hi: 0xae},
+	{value: 0x0014, lo: 0xaf, hi: 0xb7},
+	{value: 0x0010, lo: 0xb8, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xba},
+	// Block 0xe1, offset 0x4ea
+	{value: 0x5f53, lo: 0xa0, hi: 0xbf},
+	// Block 0xe2, offset 0x4eb
+	{value: 0x5f52, lo: 0x80, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0xe3, offset 0x4ee
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0010, lo: 0x89, hi: 0x89},
+	{value: 0x0010, lo: 0x8c, hi: 0x93},
+	{value: 0x0010, lo: 0x95, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0xb5},
+	{value: 0x0010, lo: 0xb7, hi: 0xb8},
+	{value: 0x0014, lo: 0xbb, hi: 0xbc},
+	{value: 0x0030, lo: 0xbd, hi: 0xbd},
+	{value: 0x0034, lo: 0xbe, hi: 0xbe},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0xe4, offset 0x4f8
+	{value: 0x0010, lo: 0x80, hi: 0x82},
+	{value: 0x0034, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0xe5, offset 0x4fb
+	{value: 0x0010, lo: 0xa0, hi: 0xa7},
+	{value: 0x0010, lo: 0xaa, hi: 0xbf},
+	// Block 0xe6, offset 0x4fd
+	{value: 0x0010, lo: 0x80, hi: 0x93},
+	{value: 0x0014, lo: 0x94, hi: 0x97},
+	{value: 0x0014, lo: 0x9a, hi: 0x9b},
+	{value: 0x0010, lo: 0x9c, hi: 0x9f},
+	{value: 0x0034, lo: 0xa0, hi: 0xa0},
+	{value: 0x0010, lo: 0xa1, hi: 0xa1},
+	{value: 0x0010, lo: 0xa3, hi: 0xa4},
+	// Block 0xe7, offset 0x504
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x8a},
+	{value: 0x0010, lo: 0x8b, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	{value: 0x0014, lo: 0xb5, hi: 0xb8},
+	{value: 0x0010, lo: 0xb9, hi: 0xba},
+	{value: 0x0014, lo: 0xbb, hi: 0xbe},
+	// Block 0xe8, offset 0x50c
+	{value: 0x0034, lo: 0x87, hi: 0x87},
+	{value: 0x0010, lo: 0x90, hi: 0x90},
+	{value: 0x0014, lo: 0x91, hi: 0x96},
+	{value: 0x0010, lo: 0x97, hi: 0x98},
+	{value: 0x0014, lo: 0x99, hi: 0x9b},
+	{value: 0x0010, lo: 0x9c, hi: 0xbf},
+	// Block 0xe9, offset 0x512
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0014, lo: 0x8a, hi: 0x96},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0014, lo: 0x98, hi: 0x98},
+	{value: 0x0034, lo: 0x99, hi: 0x99},
+	{value: 0x0010, lo: 0x9d, hi: 0x9d},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xea, offset 0x519
+	{value: 0x0010, lo: 0x80, hi: 0xb8},
+	// Block 0xeb, offset 0x51a
+	{value: 0x0010, lo: 0x80, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0xaf},
+	{value: 0x0014, lo: 0xb0, hi: 0xb6},
+	{value: 0x0014, lo: 0xb8, hi: 0xbd},
+	{value: 0x0010, lo: 0xbe, hi: 0xbe},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0xec, offset 0x520
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0010, lo: 0xb2, hi: 0xbf},
+	// Block 0xed, offset 0x523
+	{value: 0x0010, lo: 0x80, hi: 0x8f},
+	{value: 0x0014, lo: 0x92, hi: 0xa7},
+	{value: 0x0010, lo: 0xa9, hi: 0xa9},
+	{value: 0x0014, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb1, hi: 0xb1},
+	{value: 0x0014, lo: 0xb2, hi: 0xb3},
+	{value: 0x0010, lo: 0xb4, hi: 0xb4},
+	{value: 0x0014, lo: 0xb5, hi: 0xb6},
+	// Block 0xee, offset 0x52b
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0010, lo: 0x88, hi: 0x89},
+	{value: 0x0010, lo: 0x8b, hi: 0xb0},
+	{value: 0x0014, lo: 0xb1, hi: 0xb6},
+	{value: 0x0014, lo: 0xba, hi: 0xba},
+	{value: 0x0014, lo: 0xbc, hi: 0xbd},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0xef, offset 0x532
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x82},
+	{value: 0x0014, lo: 0x83, hi: 0x83},
+	{value: 0x0034, lo: 0x84, hi: 0x85},
+	{value: 0x0010, lo: 0x86, hi: 0x86},
+	{value: 0x0014, lo: 0x87, hi: 0x87},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0010, lo: 0xa0, hi: 0xa5},
+	{value: 0x0010, lo: 0xa7, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xbf},
+	// Block 0xf0, offset 0x53c
+	{value: 0x0010, lo: 0x80, hi: 0x8e},
+	{value: 0x0014, lo: 0x90, hi: 0x91},
+	{value: 0x0010, lo: 0x93, hi: 0x94},
+	{value: 0x0014, lo: 0x95, hi: 0x95},
+	{value: 0x0010, lo: 0x96, hi: 0x96},
+	{value: 0x0034, lo: 0x97, hi: 0x97},
+	{value: 0x0010, lo: 0x98, hi: 0x98},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	// Block 0xf1, offset 0x544
+	{value: 0x0010, lo: 0xa0, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb4},
+	{value: 0x0010, lo: 0xb5, hi: 0xb6},
+	// Block 0xf2, offset 0x547
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0xb5},
+	{value: 0x0014, lo: 0xb6, hi: 0xba},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0xf3, offset 0x54c
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0030, lo: 0x81, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x82},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0xf4, offset 0x550
+	{value: 0x0010, lo: 0xb0, hi: 0xb0},
+	// Block 0xf5, offset 0x551
+	{value: 0x0010, lo: 0x80, hi: 0x99},
+	// Block 0xf6, offset 0x552
+	{value: 0x0010, lo: 0x80, hi: 0xae},
+	// Block 0xf7, offset 0x553
+	{value: 0x0010, lo: 0x80, hi: 0x83},
+	// Block 0xf8, offset 0x554
+	{value: 0x0010, lo: 0x80, hi: 0xb0},
+	// Block 0xf9, offset 0x555
+	{value: 0x0010, lo: 0x80, hi: 0xaf},
+	{value: 0x0014, lo: 0xb0, hi: 0xbf},
+	// Block 0xfa, offset 0x557
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x86},
+	{value: 0x0014, lo: 0x87, hi: 0x95},
+	// Block 0xfb, offset 0x55a
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	// Block 0xfc, offset 0x55b
+	{value: 0x0010, lo: 0x80, hi: 0x9e},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xfd, offset 0x55e
+	{value: 0x0010, lo: 0x80, hi: 0xbe},
+	// Block 0xfe, offset 0x55f
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x90, hi: 0xad},
+	{value: 0x0034, lo: 0xb0, hi: 0xb4},
+	// Block 0xff, offset 0x562
+	{value: 0x0010, lo: 0x80, hi: 0xaf},
+	{value: 0x0024, lo: 0xb0, hi: 0xb6},
+	// Block 0x100, offset 0x564
+	{value: 0x0014, lo: 0x80, hi: 0x83},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0010, lo: 0xa3, hi: 0xb7},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x101, offset 0x568
+	{value: 0x0010, lo: 0x80, hi: 0x8f},
+	// Block 0x102, offset 0x569
+	{value: 0x2013, lo: 0x80, hi: 0x9f},
+	{value: 0x2012, lo: 0xa0, hi: 0xbf},
+	// Block 0x103, offset 0x56b
+	{value: 0x0010, lo: 0x80, hi: 0x8a},
+	{value: 0x0014, lo: 0x8f, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0xbf},
+	// Block 0x104, offset 0x56e
+	{value: 0x0010, lo: 0x80, hi: 0x87},
+	{value: 0x0014, lo: 0x8f, hi: 0x9f},
+	// Block 0x105, offset 0x570
+	{value: 0x0014, lo: 0xa0, hi: 0xa1},
+	{value: 0x0014, lo: 0xa3, hi: 0xa4},
+	{value: 0x0030, lo: 0xb0, hi: 0xb1},
+	// Block 0x106, offset 0x573
+	{value: 0x0004, lo: 0xb0, hi: 0xb3},
+	{value: 0x0004, lo: 0xb5, hi: 0xbb},
+	{value: 0x0004, lo: 0xbd, hi: 0xbe},
+	// Block 0x107, offset 0x576
+	{value: 0x0010, lo: 0x80, hi: 0xaa},
+	{value: 0x0010, lo: 0xb0, hi: 0xbc},
+	// Block 0x108, offset 0x578
+	{value: 0x0010, lo: 0x80, hi: 0x88},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0014, lo: 0x9d, hi: 0x9d},
+	{value: 0x0034, lo: 0x9e, hi: 0x9e},
+	{value: 0x0014, lo: 0xa0, hi: 0xa3},
+	// Block 0x109, offset 0x57d
+	{value: 0x0014, lo: 0x80, hi: 0xad},
+	{value: 0x0014, lo: 0xb0, hi: 0xbf},
+	// Block 0x10a, offset 0x57f
+	{value: 0x0014, lo: 0x80, hi: 0x86},
+	// Block 0x10b, offset 0x580
+	{value: 0x0030, lo: 0xa5, hi: 0xa6},
+	{value: 0x0034, lo: 0xa7, hi: 0xa9},
+	{value: 0x0030, lo: 0xad, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xba},
+	{value: 0x0034, lo: 0xbb, hi: 0xbf},
+	// Block 0x10c, offset 0x585
+	{value: 0x0034, lo: 0x80, hi: 0x82},
+	{value: 0x0024, lo: 0x85, hi: 0x89},
+	{value: 0x0034, lo: 0x8a, hi: 0x8b},
+	{value: 0x0024, lo: 0xaa, hi: 0xad},
+	// Block 0x10d, offset 0x589
+	{value: 0x0024, lo: 0x82, hi: 0x84},
+	// Block 0x10e, offset 0x58a
+	{value: 0x0013, lo: 0x80, hi: 0x99},
+	{value: 0x0012, lo: 0x9a, hi: 0xb3},
+	{value: 0x0013, lo: 0xb4, hi: 0xbf},
+	// Block 0x10f, offset 0x58d
+	{value: 0x0013, lo: 0x80, hi: 0x8d},
+	{value: 0x0012, lo: 0x8e, hi: 0x94},
+	{value: 0x0012, lo: 0x96, hi: 0xa7},
+	{value: 0x0013, lo: 0xa8, hi: 0xbf},
+	// Block 0x110, offset 0x591
+	{value: 0x0013, lo: 0x80, hi: 0x81},
+	{value: 0x0012, lo: 0x82, hi: 0x9b},
+	{value: 0x0013, lo: 0x9c, hi: 0x9c},
+	{value: 0x0013, lo: 0x9e, hi: 0x9f},
+	{value: 0x0013, lo: 0xa2, hi: 0xa2},
+	{value: 0x0013, lo: 0xa5, hi: 0xa6},
+	{value: 0x0013, lo: 0xa9, hi: 0xac},
+	{value: 0x0013, lo: 0xae, hi: 0xb5},
+	{value: 0x0012, lo: 0xb6, hi: 0xb9},
+	{value: 0x0012, lo: 0xbb, hi: 0xbb},
+	{value: 0x0012, lo: 0xbd, hi: 0xbf},
+	// Block 0x111, offset 0x59c
+	{value: 0x0012, lo: 0x80, hi: 0x83},
+	{value: 0x0012, lo: 0x85, hi: 0x8f},
+	{value: 0x0013, lo: 0x90, hi: 0xa9},
+	{value: 0x0012, lo: 0xaa, hi: 0xbf},
+	// Block 0x112, offset 0x5a0
+	{value: 0x0012, lo: 0x80, hi: 0x83},
+	{value: 0x0013, lo: 0x84, hi: 0x85},
+	{value: 0x0013, lo: 0x87, hi: 0x8a},
+	{value: 0x0013, lo: 0x8d, hi: 0x94},
+	{value: 0x0013, lo: 0x96, hi: 0x9c},
+	{value: 0x0012, lo: 0x9e, hi: 0xb7},
+	{value: 0x0013, lo: 0xb8, hi: 0xb9},
+	{value: 0x0013, lo: 0xbb, hi: 0xbe},
+	// Block 0x113, offset 0x5a8
+	{value: 0x0013, lo: 0x80, hi: 0x84},
+	{value: 0x0013, lo: 0x86, hi: 0x86},
+	{value: 0x0013, lo: 0x8a, hi: 0x90},
+	{value: 0x0012, lo: 0x92, hi: 0xab},
+	{value: 0x0013, lo: 0xac, hi: 0xbf},
+	// Block 0x114, offset 0x5ad
+	{value: 0x0013, lo: 0x80, hi: 0x85},
+	{value: 0x0012, lo: 0x86, hi: 0x9f},
+	{value: 0x0013, lo: 0xa0, hi: 0xb9},
+	{value: 0x0012, lo: 0xba, hi: 0xbf},
+	// Block 0x115, offset 0x5b1
+	{value: 0x0012, lo: 0x80, hi: 0x93},
+	{value: 0x0013, lo: 0x94, hi: 0xad},
+	{value: 0x0012, lo: 0xae, hi: 0xbf},
+	// Block 0x116, offset 0x5b4
+	{value: 0x0012, lo: 0x80, hi: 0x87},
+	{value: 0x0013, lo: 0x88, hi: 0xa1},
+	{value: 0x0012, lo: 0xa2, hi: 0xbb},
+	{value: 0x0013, lo: 0xbc, hi: 0xbf},
+	// Block 0x117, offset 0x5b8
+	{value: 0x0013, lo: 0x80, hi: 0x95},
+	{value: 0x0012, lo: 0x96, hi: 0xaf},
+	{value: 0x0013, lo: 0xb0, hi: 0xbf},
+	// Block 0x118, offset 0x5bb
+	{value: 0x0013, lo: 0x80, hi: 0x89},
+	{value: 0x0012, lo: 0x8a, hi: 0xa5},
+	{value: 0x0013, lo: 0xa8, hi: 0xbf},
+	// Block 0x119, offset 0x5be
+	{value: 0x0013, lo: 0x80, hi: 0x80},
+	{value: 0x0012, lo: 0x82, hi: 0x9a},
+	{value: 0x0012, lo: 0x9c, hi: 0xa1},
+	{value: 0x0013, lo: 0xa2, hi: 0xba},
+	{value: 0x0012, lo: 0xbc, hi: 0xbf},
+	// Block 0x11a, offset 0x5c3
+	{value: 0x0012, lo: 0x80, hi: 0x94},
+	{value: 0x0012, lo: 0x96, hi: 0x9b},
+	{value: 0x0013, lo: 0x9c, hi: 0xb4},
+	{value: 0x0012, lo: 0xb6, hi: 0xbf},
+	// Block 0x11b, offset 0x5c7
+	{value: 0x0012, lo: 0x80, hi: 0x8e},
+	{value: 0x0012, lo: 0x90, hi: 0x95},
+	{value: 0x0013, lo: 0x96, hi: 0xae},
+	{value: 0x0012, lo: 0xb0, hi: 0xbf},
+	// Block 0x11c, offset 0x5cb
+	{value: 0x0012, lo: 0x80, hi: 0x88},
+	{value: 0x0012, lo: 0x8a, hi: 0x8f},
+	{value: 0x0013, lo: 0x90, hi: 0xa8},
+	{value: 0x0012, lo: 0xaa, hi: 0xbf},
+	// Block 0x11d, offset 0x5cf
+	{value: 0x0012, lo: 0x80, hi: 0x82},
+	{value: 0x0012, lo: 0x84, hi: 0x89},
+	{value: 0x0017, lo: 0x8a, hi: 0x8b},
+	{value: 0x0010, lo: 0x8e, hi: 0xbf},
+	// Block 0x11e, offset 0x5d3
+	{value: 0x0014, lo: 0x80, hi: 0xb6},
+	{value: 0x0014, lo: 0xbb, hi: 0xbf},
+	// Block 0x11f, offset 0x5d5
+	{value: 0x0014, lo: 0x80, hi: 0xac},
+	{value: 0x0014, lo: 0xb5, hi: 0xb5},
+	// Block 0x120, offset 0x5d7
+	{value: 0x0014, lo: 0x84, hi: 0x84},
+	{value: 0x0014, lo: 0x9b, hi: 0x9f},
+	{value: 0x0014, lo: 0xa1, hi: 0xaf},
+	// Block 0x121, offset 0x5da
+	{value: 0x0012, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x8a, hi: 0x8a},
+	{value: 0x0012, lo: 0x8b, hi: 0x9e},
+	{value: 0x0012, lo: 0xa5, hi: 0xaa},
+	// Block 0x122, offset 0x5de
+	{value: 0x0024, lo: 0x80, hi: 0x86},
+	{value: 0x0024, lo: 0x88, hi: 0x98},
+	{value: 0x0024, lo: 0x9b, hi: 0xa1},
+	{value: 0x0024, lo: 0xa3, hi: 0xa4},
+	{value: 0x0024, lo: 0xa6, hi: 0xaa},
+	{value: 0x0015, lo: 0xb0, hi: 0xbf},
+	// Block 0x123, offset 0x5e4
+	{value: 0x0015, lo: 0x80, hi: 0xad},
+	// Block 0x124, offset 0x5e5
+	{value: 0x0024, lo: 0x8f, hi: 0x8f},
+	// Block 0x125, offset 0x5e6
+	{value: 0x0010, lo: 0x80, hi: 0xac},
+	{value: 0x0024, lo: 0xb0, hi: 0xb6},
+	{value: 0x0014, lo: 0xb7, hi: 0xbd},
+	// Block 0x126, offset 0x5e9
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x8e, hi: 0x8e},
+	// Block 0x127, offset 0x5eb
+	{value: 0x0010, lo: 0x90, hi: 0xad},
+	{value: 0x0024, lo: 0xae, hi: 0xae},
+	// Block 0x128, offset 0x5ed
+	{value: 0x0010, lo: 0x80, hi: 0xab},
+	{value: 0x0024, lo: 0xac, hi: 0xaf},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x129, offset 0x5f0
+	{value: 0x0010, lo: 0x90, hi: 0xaa},
+	{value: 0x0014, lo: 0xab, hi: 0xab},
+	{value: 0x0034, lo: 0xac, hi: 0xae},
+	{value: 0x0024, lo: 0xaf, hi: 0xaf},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x12a, offset 0x5f5
+	{value: 0x0010, lo: 0xa0, hi: 0xa6},
+	{value: 0x0010, lo: 0xa8, hi: 0xab},
+	{value: 0x0010, lo: 0xad, hi: 0xae},
+	{value: 0x0010, lo: 0xb0, hi: 0xbe},
+	// Block 0x12b, offset 0x5f9
+	{value: 0x0010, lo: 0x80, hi: 0x84},
+	{value: 0x0034, lo: 0x90, hi: 0x96},
+	// Block 0x12c, offset 0x5fb
+	{value: 0xd152, lo: 0x80, hi: 0x81},
+	{value: 0xd452, lo: 0x82, hi: 0x83},
+	{value: 0x0024, lo: 0x84, hi: 0x89},
+	{value: 0x0034, lo: 0x8a, hi: 0x8a},
+	{value: 0x0014, lo: 0x8b, hi: 0x8b},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0x12d, offset 0x601
+	{value: 0x0010, lo: 0x80, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x9f},
+	{value: 0x0010, lo: 0xa1, hi: 0xa2},
+	{value: 0x0010, lo: 0xa4, hi: 0xa4},
+	{value: 0x0010, lo: 0xa7, hi: 0xa7},
+	{value: 0x0010, lo: 0xa9, hi: 0xb2},
+	{value: 0x0010, lo: 0xb4, hi: 0xb7},
+	{value: 0x0010, lo: 0xb9, hi: 0xb9},
+	{value: 0x0010, lo: 0xbb, hi: 0xbb},
+	// Block 0x12e, offset 0x60a
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x8b, hi: 0x9b},
+	{value: 0x0010, lo: 0xa1, hi: 0xa3},
+	{value: 0x0010, lo: 0xa5, hi: 0xa9},
+	{value: 0x0010, lo: 0xab, hi: 0xbb},
+	// Block 0x12f, offset 0x60f
+	{value: 0x0013, lo: 0xb0, hi: 0xbf},
+	// Block 0x130, offset 0x610
+	{value: 0x0013, lo: 0x80, hi: 0x89},
+	{value: 0x0013, lo: 0x90, hi: 0xa9},
+	{value: 0x0013, lo: 0xb0, hi: 0xbf},
+	// Block 0x131, offset 0x613
+	{value: 0x0013, lo: 0x80, hi: 0x89},
+	// Block 0x132, offset 0x614
+	{value: 0x0014, lo: 0xbb, hi: 0xbf},
+	// Block 0x133, offset 0x615
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x134, offset 0x616
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0014, lo: 0xa0, hi: 0xbf},
+	// Block 0x135, offset 0x618
+	{value: 0x0014, lo: 0x80, hi: 0xbf},
+	// Block 0x136, offset 0x619
+	{value: 0x0014, lo: 0x80, hi: 0xaf},
+}
+
+// Total table size 16093 bytes (15KiB); checksum: EE91C452
diff --git a/vendor/golang.org/x/text/cases/tables17.0.0.go b/vendor/golang.org/x/text/cases/tables17.0.0.go
new file mode 100644
index 00000000000..cee93cbdc84
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/tables17.0.0.go
@@ -0,0 +1,2642 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+//go:build go1.27
+
+package cases
+
+// UnicodeVersion is the Unicode version from which the tables in this package are derived.
+const UnicodeVersion = "17.0.0"
+
+var xorData string = "" + // Size: 237 bytes
+	"\x00\x06\x07\x00\x01?\x00\x0f\x03\x00\x0f\x12\x00\x0f\x1f\x00\x0f\x1d" +
+	"\x00\x01\x13\x00\x0f\x16\x00\x0f\x0b\x00\x0f3\x00\x0f7\x00\x01#\x00\x0f?" +
+	"\x00\x0e'\x00\x0f/\x00\x0e>\x00\x0f*\x00\x0c&\x00\x0c*\x00\x0c;\x00\x0c9" +
+	"\x00\x0c%\x00\x01\x08\x00\x03\x0d\x00\x03\x09\x00\x02\x06\x00\x02\x02" +
+	"\x00\x02\x0c\x00\x01\x00\x00\x01\x03\x00\x01\x01\x00\x01 \x00\x01\x0c" +
+	"\x00\x01\x10\x00\x03\x10\x00\x036 \x00\x037 \x00\x0b#\x10\x00\x0b 0\x00" +
+	"\x0b!\x10\x00\x0b!0\x001\x00\x00\x0b(\x04\x00\x03\x04\x1e\x00\x0b)\x08" +
+	"\x00\x03\x0a\x00\x02:\x00\x02>\x00\x02,\x00\x02\x00\x00\x02\x10\x00\x01<" +
+	"\x00\x01&\x00\x01*\x00\x01.\x00\x010\x003 \x00\x01\x18\x00\x01(\x00\x03'" +
+	"\x00\x03)\x00\x03+\x00\x03/\x00\x03\x19\x00\x03\x1b\x00\x03\x1f\x00\x03 " +
+	"\x00\x01%\x00\x01'\x00\x01+\x00\x01-\x00\x01/\x00\x01;\x00\x01=\x00\x01" +
+	"\x1e\x00\x01\x22"
+
+var exceptions string = "" + // Size: 2478 bytes
+	"\x00\x12\x12μΜΜ\x12\x12ssSSSs\x13\x18i̇i̇\x10\x09II\x13\x1bʼnʼNʼN\x11" +
+	"\x09sSS\x10\x1bꟜꟜ\x12\x12dždžDž\x12\x12dždžDŽ\x10\x12DŽDž\x12\x12ljljLj\x12\x12ljljLJ" +
+	"\x10\x12LJLj\x12\x12njnjNj\x12\x12njnjNJ\x10\x12NJNj\x13\x1bǰJ̌J̌\x12\x12dzdzDz\x12" +
+	"\x12dzdzDZ\x10\x12DZDz\x13\x18ⱥⱥ\x13\x18ⱦⱦ\x10\x1bⱾⱾ\x10\x1bⱿⱿ\x10\x1bⱯⱯ\x10" +
+	"\x1bⱭⱭ\x10\x1bⱰⱰ\x10\x1bꞫꞫ\x10\x1bꞬꞬ\x10\x1bꟋꟋ\x10\x1bꞍꞍ\x10\x1bꞪꞪ\x10" +
+	"\x1bꞮꞮ\x10\x1bⱢⱢ\x10\x1bꞭꞭ\x10\x1bⱮⱮ\x10\x1bⱤⱤ\x10\x1bꟅꟅ\x10\x1bꞱꞱ\x10" +
+	"\x1bꞲꞲ\x10\x1bꞰꞰ2\x12ιΙΙ\x166ΐΪ́Ϊ́\x166ΰΫ́Ϋ́\x12\x12σΣΣ\x12\x12β" +
+	"ΒΒ\x12\x12θΘΘ\x12\x12φΦΦ\x12\x12πΠΠ\x12\x12κΚΚ\x12\x12ρΡΡ\x12\x12εΕΕ" +
+	"\x14$եւԵՒԵւ\x10\x1bᲐა\x10\x1bᲑბ\x10\x1bᲒგ\x10\x1bᲓდ\x10\x1bᲔე\x10\x1bᲕვ" +
+	"\x10\x1bᲖზ\x10\x1bᲗთ\x10\x1bᲘი\x10\x1bᲙკ\x10\x1bᲚლ\x10\x1bᲛმ\x10\x1bᲜნ" +
+	"\x10\x1bᲝო\x10\x1bᲞპ\x10\x1bᲟჟ\x10\x1bᲠრ\x10\x1bᲡს\x10\x1bᲢტ\x10\x1bᲣუ" +
+	"\x10\x1bᲤფ\x10\x1bᲥქ\x10\x1bᲦღ\x10\x1bᲧყ\x10\x1bᲨშ\x10\x1bᲩჩ\x10\x1bᲪც" +
+	"\x10\x1bᲫძ\x10\x1bᲬწ\x10\x1bᲭჭ\x10\x1bᲮხ\x10\x1bᲯჯ\x10\x1bᲰჰ\x10\x1bᲱჱ" +
+	"\x10\x1bᲲჲ\x10\x1bᲳჳ\x10\x1bᲴჴ\x10\x1bᲵჵ\x10\x1bᲶჶ\x10\x1bᲷჷ\x10\x1bᲸჸ" +
+	"\x10\x1bᲹჹ\x10\x1bᲺჺ\x10\x1bᲽჽ\x10\x1bᲾჾ\x10\x1bᲿჿ\x12\x12вВВ\x12\x12дДД" +
+	"\x12\x12оОО\x12\x12сСС\x12\x12тТТ\x12\x12тТТ\x12\x12ъЪЪ\x12\x12ѣѢѢ\x13" +
+	"\x1bꙋꙊꙊ\x13\x1bẖH̱H̱\x13\x1bẗT̈T̈\x13\x1bẘW̊W̊\x13\x1bẙY̊Y̊\x13\x1ba" +
+	"ʾAʾAʾ\x13\x1bṡṠṠ\x12\x10ssß\x14$ὐΥ̓Υ̓\x166ὒΥ̓̀Υ̓̀\x166ὔΥ̓́Υ̓́\x166" +
+	"ὖΥ̓͂Υ̓͂\x15+ἀιἈΙᾈ\x15+ἁιἉΙᾉ\x15+ἂιἊΙᾊ\x15+ἃιἋΙᾋ\x15+ἄιἌΙᾌ\x15+ἅιἍΙᾍ" +
+	"\x15+ἆιἎΙᾎ\x15+ἇιἏΙᾏ\x15\x1dἀιᾀἈΙ\x15\x1dἁιᾁἉΙ\x15\x1dἂιᾂἊΙ\x15\x1dἃιᾃἋΙ" +
+	"\x15\x1dἄιᾄἌΙ\x15\x1dἅιᾅἍΙ\x15\x1dἆιᾆἎΙ\x15\x1dἇιᾇἏΙ\x15+ἠιἨΙᾘ\x15+ἡιἩΙᾙ" +
+	"\x15+ἢιἪΙᾚ\x15+ἣιἫΙᾛ\x15+ἤιἬΙᾜ\x15+ἥιἭΙᾝ\x15+ἦιἮΙᾞ\x15+ἧιἯΙᾟ\x15\x1dἠιᾐἨ" +
+	"Ι\x15\x1dἡιᾑἩΙ\x15\x1dἢιᾒἪΙ\x15\x1dἣιᾓἫΙ\x15\x1dἤιᾔἬΙ\x15\x1dἥιᾕἭΙ\x15" +
+	"\x1dἦιᾖἮΙ\x15\x1dἧιᾗἯΙ\x15+ὠιὨΙᾨ\x15+ὡιὩΙᾩ\x15+ὢιὪΙᾪ\x15+ὣιὫΙᾫ\x15+ὤιὬΙᾬ" +
+	"\x15+ὥιὭΙᾭ\x15+ὦιὮΙᾮ\x15+ὧιὯΙᾯ\x15\x1dὠιᾠὨΙ\x15\x1dὡιᾡὩΙ\x15\x1dὢιᾢὪΙ" +
+	"\x15\x1dὣιᾣὫΙ\x15\x1dὤιᾤὬΙ\x15\x1dὥιᾥὭΙ\x15\x1dὦιᾦὮΙ\x15\x1dὧιᾧὯΙ\x15-ὰι" +
+	"ᾺΙᾺͅ\x14#αιΑΙᾼ\x14$άιΆΙΆͅ\x14$ᾶΑ͂Α͂\x166ᾶιΑ͂Ιᾼ͂\x14\x1cαιᾳΑΙ\x12" +
+	"\x12ιΙΙ\x15-ὴιῊΙῊͅ\x14#ηιΗΙῌ\x14$ήιΉΙΉͅ\x14$ῆΗ͂Η͂\x166ῆιΗ͂Ιῌ͂\x14\x1c" +
+	"ηιῃΗΙ\x166ῒΪ̀Ϊ̀\x166ΐΪ́Ϊ́\x14$ῖΙ͂Ι͂\x166ῗΪ͂Ϊ͂\x166ῢΫ̀Ϋ" +
+	"̀\x166ΰΫ́Ϋ́\x14$ῤΡ̓Ρ̓\x14$ῦΥ͂Υ͂\x166ῧΫ͂Ϋ͂\x15-ὼιῺΙῺͅ\x14#ωιΩΙ" +
+	"ῼ\x14$ώιΏΙΏͅ\x14$ῶΩ͂Ω͂\x166ῶιΩ͂Ιῼ͂\x14\x1cωιῳΩΙ\x12\x10ωω\x11\x08kk" +
+	"\x12\x10åå\x12\x10ɫɫ\x12\x10ɽɽ\x10\x12ȺȺ\x10\x12ȾȾ\x12\x10ɑɑ\x12\x10ɱɱ" +
+	"\x12\x10ɐɐ\x12\x10ɒɒ\x12\x10ȿȿ\x12\x10ɀɀ\x12\x10ɥɥ\x12\x10ɦɦ\x12\x10ɜɜ" +
+	"\x12\x10ɡɡ\x12\x10ɬɬ\x12\x10ɪɪ\x12\x10ʞʞ\x12\x10ʇʇ\x12\x10ʝʝ\x12\x10ʂʂ" +
+	"\x12\x10ɤɤ\x12\x10ƛƛ\x12\x12ffFFFf\x12\x12fiFIFi\x12\x12flFLFl\x13\x1bff" +
+	"iFFIFfi\x13\x1bfflFFLFfl\x12\x12stSTSt\x12\x12stSTSt\x14$մնՄՆՄն\x14$մեՄԵ" +
+	"Մե\x14$միՄԻՄի\x14$վնՎՆՎն\x14$մխՄԽՄխ"
+
+// 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 *caseTrie) lookup(s []byte) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return caseValues[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 := caseIndex[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 := caseIndex[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 = caseIndex[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 := caseIndex[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 = caseIndex[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 = caseIndex[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 *caseTrie) lookupUnsafe(s []byte) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return caseValues[c0]
+	}
+	i := caseIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = caseIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = caseIndex[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 *caseTrie) lookupString(s string) (v uint16, sz int) {
+	c0 := s[0]
+	switch {
+	case c0 < 0x80: // is ASCII
+		return caseValues[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 := caseIndex[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 := caseIndex[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 = caseIndex[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 := caseIndex[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 = caseIndex[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 = caseIndex[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 *caseTrie) lookupStringUnsafe(s string) uint16 {
+	c0 := s[0]
+	if c0 < 0x80 { // is ASCII
+		return caseValues[c0]
+	}
+	i := caseIndex[c0]
+	if c0 < 0xE0 { // 2-byte UTF-8
+		return t.lookupValue(uint32(i), s[1])
+	}
+	i = caseIndex[uint32(i)<<6+uint32(s[1])]
+	if c0 < 0xF0 { // 3-byte UTF-8
+		return t.lookupValue(uint32(i), s[2])
+	}
+	i = caseIndex[uint32(i)<<6+uint32(s[2])]
+	if c0 < 0xF8 { // 4-byte UTF-8
+		return t.lookupValue(uint32(i), s[3])
+	}
+	return 0
+}
+
+// caseTrie. Total size: 14000 bytes (13.67 KiB). Checksum: 76c852e9b991a172.
+type caseTrie struct{}
+
+func newCaseTrie(i int) *caseTrie {
+	return &caseTrie{}
+}
+
+// lookupValue determines the type of block n and looks up the value for b.
+func (t *caseTrie) lookupValue(n uint32, b byte) uint16 {
+	switch {
+	case n < 24:
+		return uint16(caseValues[n<<6+uint32(b)])
+	default:
+		n -= 24
+		return uint16(sparse.lookup(n, b))
+	}
+}
+
+// caseValues: 26 blocks, 1664 entries, 3328 bytes
+// The third block is the zero block.
+var caseValues = [1664]uint16{
+	// Block 0x0, offset 0x0
+	0x27: 0x0054,
+	0x2e: 0x0054,
+	0x30: 0x0010, 0x31: 0x0010, 0x32: 0x0010, 0x33: 0x0010, 0x34: 0x0010, 0x35: 0x0010,
+	0x36: 0x0010, 0x37: 0x0010, 0x38: 0x0010, 0x39: 0x0010, 0x3a: 0x0054,
+	// Block 0x1, offset 0x40
+	0x41: 0x2013, 0x42: 0x2013, 0x43: 0x2013, 0x44: 0x2013, 0x45: 0x2013,
+	0x46: 0x2013, 0x47: 0x2013, 0x48: 0x2013, 0x49: 0x2013, 0x4a: 0x2013, 0x4b: 0x2013,
+	0x4c: 0x2013, 0x4d: 0x2013, 0x4e: 0x2013, 0x4f: 0x2013, 0x50: 0x2013, 0x51: 0x2013,
+	0x52: 0x2013, 0x53: 0x2013, 0x54: 0x2013, 0x55: 0x2013, 0x56: 0x2013, 0x57: 0x2013,
+	0x58: 0x2013, 0x59: 0x2013, 0x5a: 0x2013,
+	0x5e: 0x0004, 0x5f: 0x0010, 0x60: 0x0004, 0x61: 0x2012, 0x62: 0x2012, 0x63: 0x2012,
+	0x64: 0x2012, 0x65: 0x2012, 0x66: 0x2012, 0x67: 0x2012, 0x68: 0x2012, 0x69: 0x2012,
+	0x6a: 0x2012, 0x6b: 0x2012, 0x6c: 0x2012, 0x6d: 0x2012, 0x6e: 0x2012, 0x6f: 0x2012,
+	0x70: 0x2012, 0x71: 0x2012, 0x72: 0x2012, 0x73: 0x2012, 0x74: 0x2012, 0x75: 0x2012,
+	0x76: 0x2012, 0x77: 0x2012, 0x78: 0x2012, 0x79: 0x2012, 0x7a: 0x2012,
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc0: 0x0852, 0xc1: 0x0b53, 0xc2: 0x0113, 0xc3: 0x0112, 0xc4: 0x0113, 0xc5: 0x0112,
+	0xc6: 0x0b53, 0xc7: 0x0f13, 0xc8: 0x0f12, 0xc9: 0x0e53, 0xca: 0x1153, 0xcb: 0x0713,
+	0xcc: 0x0712, 0xcd: 0x0012, 0xce: 0x1453, 0xcf: 0x1753, 0xd0: 0x1a53, 0xd1: 0x0313,
+	0xd2: 0x0312, 0xd3: 0x1d53, 0xd4: 0x2053, 0xd5: 0x2352, 0xd6: 0x2653, 0xd7: 0x2653,
+	0xd8: 0x0113, 0xd9: 0x0112, 0xda: 0x2952, 0xdb: 0x02da, 0xdc: 0x1d53, 0xdd: 0x2c53,
+	0xde: 0x2f52, 0xdf: 0x3253, 0xe0: 0x0113, 0xe1: 0x0112, 0xe2: 0x0113, 0xe3: 0x0112,
+	0xe4: 0x0113, 0xe5: 0x0112, 0xe6: 0x3553, 0xe7: 0x0f13, 0xe8: 0x0f12, 0xe9: 0x3853,
+	0xea: 0x0012, 0xeb: 0x0012, 0xec: 0x0113, 0xed: 0x0112, 0xee: 0x3553, 0xef: 0x1f13,
+	0xf0: 0x1f12, 0xf1: 0x3b53, 0xf2: 0x3e53, 0xf3: 0x0713, 0xf4: 0x0712, 0xf5: 0x0313,
+	0xf6: 0x0312, 0xf7: 0x4153, 0xf8: 0x0113, 0xf9: 0x0112, 0xfa: 0x0012, 0xfb: 0x0010,
+	0xfc: 0x0113, 0xfd: 0x0112, 0xfe: 0x0012, 0xff: 0x4452,
+	// Block 0x4, offset 0x100
+	0x100: 0x0010, 0x101: 0x0010, 0x102: 0x0010, 0x103: 0x0010, 0x104: 0x035b, 0x105: 0x03d9,
+	0x106: 0x045a, 0x107: 0x04bb, 0x108: 0x0539, 0x109: 0x05ba, 0x10a: 0x061b, 0x10b: 0x0699,
+	0x10c: 0x071a, 0x10d: 0x0313, 0x10e: 0x0312, 0x10f: 0x1f13, 0x110: 0x1f12, 0x111: 0x0313,
+	0x112: 0x0312, 0x113: 0x0713, 0x114: 0x0712, 0x115: 0x0313, 0x116: 0x0312, 0x117: 0x0f13,
+	0x118: 0x0f12, 0x119: 0x0313, 0x11a: 0x0312, 0x11b: 0x0713, 0x11c: 0x0712, 0x11d: 0x1452,
+	0x11e: 0x0113, 0x11f: 0x0112, 0x120: 0x0113, 0x121: 0x0112, 0x122: 0x0113, 0x123: 0x0112,
+	0x124: 0x0113, 0x125: 0x0112, 0x126: 0x0113, 0x127: 0x0112, 0x128: 0x0113, 0x129: 0x0112,
+	0x12a: 0x0113, 0x12b: 0x0112, 0x12c: 0x0113, 0x12d: 0x0112, 0x12e: 0x0113, 0x12f: 0x0112,
+	0x130: 0x077a, 0x131: 0x082b, 0x132: 0x08a9, 0x133: 0x092a, 0x134: 0x0113, 0x135: 0x0112,
+	0x136: 0x2353, 0x137: 0x4453, 0x138: 0x0113, 0x139: 0x0112, 0x13a: 0x0113, 0x13b: 0x0112,
+	0x13c: 0x0113, 0x13d: 0x0112, 0x13e: 0x0113, 0x13f: 0x0112,
+	// Block 0x5, offset 0x140
+	0x140: 0x0b0a, 0x141: 0x0313, 0x142: 0x0312, 0x143: 0x0853, 0x144: 0x4753, 0x145: 0x4a53,
+	0x146: 0x0113, 0x147: 0x0112, 0x148: 0x0113, 0x149: 0x0112, 0x14a: 0x0113, 0x14b: 0x0112,
+	0x14c: 0x0113, 0x14d: 0x0112, 0x14e: 0x0113, 0x14f: 0x0112, 0x150: 0x0b8a, 0x151: 0x0c0a,
+	0x152: 0x0c8a, 0x153: 0x0b52, 0x154: 0x0b52, 0x155: 0x0012, 0x156: 0x0e52, 0x157: 0x1152,
+	0x158: 0x0012, 0x159: 0x1752, 0x15a: 0x0012, 0x15b: 0x1a52, 0x15c: 0x0d0a, 0x15d: 0x0012,
+	0x15e: 0x0012, 0x15f: 0x0012, 0x160: 0x1d52, 0x161: 0x0d8a, 0x162: 0x0012, 0x163: 0x2052,
+	0x164: 0x0e0a, 0x165: 0x0e8a, 0x166: 0x0f0a, 0x167: 0x0012, 0x168: 0x2652, 0x169: 0x2652,
+	0x16a: 0x0f8a, 0x16b: 0x100a, 0x16c: 0x108a, 0x16d: 0x0012, 0x16e: 0x0012, 0x16f: 0x1d52,
+	0x170: 0x0012, 0x171: 0x110a, 0x172: 0x2c52, 0x173: 0x0012, 0x174: 0x0012, 0x175: 0x3252,
+	0x176: 0x0012, 0x177: 0x0012, 0x178: 0x0012, 0x179: 0x0012, 0x17a: 0x0012, 0x17b: 0x0012,
+	0x17c: 0x0012, 0x17d: 0x118a, 0x17e: 0x0012, 0x17f: 0x0012,
+	// Block 0x6, offset 0x180
+	0x180: 0x3552, 0x181: 0x0012, 0x182: 0x120a, 0x183: 0x3852, 0x184: 0x0012, 0x185: 0x0012,
+	0x186: 0x0012, 0x187: 0x128a, 0x188: 0x3552, 0x189: 0x4752, 0x18a: 0x3b52, 0x18b: 0x3e52,
+	0x18c: 0x4a52, 0x18d: 0x0012, 0x18e: 0x0012, 0x18f: 0x0012, 0x190: 0x0012, 0x191: 0x0012,
+	0x192: 0x4152, 0x193: 0x0012, 0x194: 0x0010, 0x195: 0x0010, 0x196: 0x0012, 0x197: 0x0012,
+	0x198: 0x0012, 0x199: 0x0012, 0x19a: 0x0012, 0x19b: 0x0012, 0x19c: 0x0012, 0x19d: 0x130a,
+	0x19e: 0x138a, 0x19f: 0x0012, 0x1a0: 0x0012, 0x1a1: 0x0012, 0x1a2: 0x0012, 0x1a3: 0x0012,
+	0x1a4: 0x0012, 0x1a5: 0x0012, 0x1a6: 0x0012, 0x1a7: 0x0012, 0x1a8: 0x0012, 0x1a9: 0x0012,
+	0x1aa: 0x0012, 0x1ab: 0x0012, 0x1ac: 0x0012, 0x1ad: 0x0012, 0x1ae: 0x0012, 0x1af: 0x0012,
+	0x1b0: 0x0015, 0x1b1: 0x0015, 0x1b2: 0x0015, 0x1b3: 0x0015, 0x1b4: 0x0015, 0x1b5: 0x0015,
+	0x1b6: 0x0015, 0x1b7: 0x0015, 0x1b8: 0x0015, 0x1b9: 0x0014, 0x1ba: 0x0014, 0x1bb: 0x0014,
+	0x1bc: 0x0014, 0x1bd: 0x0014, 0x1be: 0x0014, 0x1bf: 0x0014,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x0024, 0x1c1: 0x0024, 0x1c2: 0x0024, 0x1c3: 0x0024, 0x1c4: 0x0024, 0x1c5: 0x140d,
+	0x1c6: 0x0024, 0x1c7: 0x0034, 0x1c8: 0x0034, 0x1c9: 0x0034, 0x1ca: 0x0024, 0x1cb: 0x0024,
+	0x1cc: 0x0024, 0x1cd: 0x0034, 0x1ce: 0x0034, 0x1cf: 0x0014, 0x1d0: 0x0024, 0x1d1: 0x0024,
+	0x1d2: 0x0024, 0x1d3: 0x0034, 0x1d4: 0x0034, 0x1d5: 0x0034, 0x1d6: 0x0034, 0x1d7: 0x0024,
+	0x1d8: 0x0034, 0x1d9: 0x0034, 0x1da: 0x0034, 0x1db: 0x0024, 0x1dc: 0x0034, 0x1dd: 0x0034,
+	0x1de: 0x0034, 0x1df: 0x0034, 0x1e0: 0x0034, 0x1e1: 0x0034, 0x1e2: 0x0034, 0x1e3: 0x0024,
+	0x1e4: 0x0024, 0x1e5: 0x0024, 0x1e6: 0x0024, 0x1e7: 0x0024, 0x1e8: 0x0024, 0x1e9: 0x0024,
+	0x1ea: 0x0024, 0x1eb: 0x0024, 0x1ec: 0x0024, 0x1ed: 0x0024, 0x1ee: 0x0024, 0x1ef: 0x0024,
+	0x1f0: 0x0113, 0x1f1: 0x0112, 0x1f2: 0x0113, 0x1f3: 0x0112, 0x1f4: 0x0014, 0x1f5: 0x0004,
+	0x1f6: 0x0113, 0x1f7: 0x0112, 0x1fa: 0x0015, 0x1fb: 0x4d52,
+	0x1fc: 0x5052, 0x1fd: 0x5052, 0x1ff: 0x5353,
+	// Block 0x8, offset 0x200
+	0x204: 0x0004, 0x205: 0x0004,
+	0x206: 0x2a13, 0x207: 0x0054, 0x208: 0x2513, 0x209: 0x2713, 0x20a: 0x2513,
+	0x20c: 0x5653, 0x20e: 0x5953, 0x20f: 0x5c53, 0x210: 0x148a, 0x211: 0x2013,
+	0x212: 0x2013, 0x213: 0x2013, 0x214: 0x2013, 0x215: 0x2013, 0x216: 0x2013, 0x217: 0x2013,
+	0x218: 0x2013, 0x219: 0x2013, 0x21a: 0x2013, 0x21b: 0x2013, 0x21c: 0x2013, 0x21d: 0x2013,
+	0x21e: 0x2013, 0x21f: 0x2013, 0x220: 0x5f53, 0x221: 0x5f53, 0x223: 0x5f53,
+	0x224: 0x5f53, 0x225: 0x5f53, 0x226: 0x5f53, 0x227: 0x5f53, 0x228: 0x5f53, 0x229: 0x5f53,
+	0x22a: 0x5f53, 0x22b: 0x5f53, 0x22c: 0x2a12, 0x22d: 0x2512, 0x22e: 0x2712, 0x22f: 0x2512,
+	0x230: 0x15ca, 0x231: 0x2012, 0x232: 0x2012, 0x233: 0x2012, 0x234: 0x2012, 0x235: 0x2012,
+	0x236: 0x2012, 0x237: 0x2012, 0x238: 0x2012, 0x239: 0x2012, 0x23a: 0x2012, 0x23b: 0x2012,
+	0x23c: 0x2012, 0x23d: 0x2012, 0x23e: 0x2012, 0x23f: 0x2012,
+	// Block 0x9, offset 0x240
+	0x240: 0x5f52, 0x241: 0x5f52, 0x242: 0x170a, 0x243: 0x5f52, 0x244: 0x5f52, 0x245: 0x5f52,
+	0x246: 0x5f52, 0x247: 0x5f52, 0x248: 0x5f52, 0x249: 0x5f52, 0x24a: 0x5f52, 0x24b: 0x5f52,
+	0x24c: 0x5652, 0x24d: 0x5952, 0x24e: 0x5c52, 0x24f: 0x1813, 0x250: 0x178a, 0x251: 0x180a,
+	0x252: 0x0013, 0x253: 0x0013, 0x254: 0x0013, 0x255: 0x188a, 0x256: 0x190a, 0x257: 0x1812,
+	0x258: 0x0113, 0x259: 0x0112, 0x25a: 0x0113, 0x25b: 0x0112, 0x25c: 0x0113, 0x25d: 0x0112,
+	0x25e: 0x0113, 0x25f: 0x0112, 0x260: 0x0113, 0x261: 0x0112, 0x262: 0x0113, 0x263: 0x0112,
+	0x264: 0x0113, 0x265: 0x0112, 0x266: 0x0113, 0x267: 0x0112, 0x268: 0x0113, 0x269: 0x0112,
+	0x26a: 0x0113, 0x26b: 0x0112, 0x26c: 0x0113, 0x26d: 0x0112, 0x26e: 0x0113, 0x26f: 0x0112,
+	0x270: 0x198a, 0x271: 0x1a0a, 0x272: 0x0b12, 0x273: 0x5352, 0x274: 0x6253, 0x275: 0x1a8a,
+	0x277: 0x0f13, 0x278: 0x0f12, 0x279: 0x0b13, 0x27a: 0x0113, 0x27b: 0x0112,
+	0x27c: 0x0012, 0x27d: 0x4d53, 0x27e: 0x5053, 0x27f: 0x5053,
+	// Block 0xa, offset 0x280
+	0x280: 0x6852, 0x281: 0x6852, 0x282: 0x6852, 0x283: 0x6852, 0x284: 0x6852, 0x285: 0x6852,
+	0x286: 0x6852, 0x287: 0x1b0a, 0x288: 0x0012, 0x28a: 0x0010,
+	0x291: 0x0034,
+	0x292: 0x0024, 0x293: 0x0024, 0x294: 0x0024, 0x295: 0x0024, 0x296: 0x0034, 0x297: 0x0024,
+	0x298: 0x0024, 0x299: 0x0024, 0x29a: 0x0034, 0x29b: 0x0034, 0x29c: 0x0024, 0x29d: 0x0024,
+	0x29e: 0x0024, 0x29f: 0x0024, 0x2a0: 0x0024, 0x2a1: 0x0024, 0x2a2: 0x0034, 0x2a3: 0x0034,
+	0x2a4: 0x0034, 0x2a5: 0x0034, 0x2a6: 0x0034, 0x2a7: 0x0034, 0x2a8: 0x0024, 0x2a9: 0x0024,
+	0x2aa: 0x0034, 0x2ab: 0x0024, 0x2ac: 0x0024, 0x2ad: 0x0034, 0x2ae: 0x0034, 0x2af: 0x0024,
+	0x2b0: 0x0034, 0x2b1: 0x0034, 0x2b2: 0x0034, 0x2b3: 0x0034, 0x2b4: 0x0034, 0x2b5: 0x0034,
+	0x2b6: 0x0034, 0x2b7: 0x0034, 0x2b8: 0x0034, 0x2b9: 0x0034, 0x2ba: 0x0034, 0x2bb: 0x0034,
+	0x2bc: 0x0034, 0x2bd: 0x0034, 0x2bf: 0x0034,
+	// Block 0xb, offset 0x2c0
+	0x2c0: 0x0010, 0x2c1: 0x0010, 0x2c2: 0x0010, 0x2c3: 0x0010, 0x2c4: 0x0010, 0x2c5: 0x0010,
+	0x2c6: 0x0010, 0x2c7: 0x0010, 0x2c8: 0x0010, 0x2c9: 0x0014, 0x2ca: 0x0024, 0x2cb: 0x0024,
+	0x2cc: 0x0024, 0x2cd: 0x0024, 0x2ce: 0x0024, 0x2cf: 0x0034, 0x2d0: 0x0034, 0x2d1: 0x0034,
+	0x2d2: 0x0034, 0x2d3: 0x0034, 0x2d4: 0x0024, 0x2d5: 0x0024, 0x2d6: 0x0024, 0x2d7: 0x0024,
+	0x2d8: 0x0024, 0x2d9: 0x0024, 0x2da: 0x0024, 0x2db: 0x0024, 0x2dc: 0x0024, 0x2dd: 0x0024,
+	0x2de: 0x0024, 0x2df: 0x0024, 0x2e0: 0x0024, 0x2e1: 0x0024, 0x2e2: 0x0014, 0x2e3: 0x0034,
+	0x2e4: 0x0024, 0x2e5: 0x0024, 0x2e6: 0x0034, 0x2e7: 0x0024, 0x2e8: 0x0024, 0x2e9: 0x0034,
+	0x2ea: 0x0024, 0x2eb: 0x0024, 0x2ec: 0x0024, 0x2ed: 0x0034, 0x2ee: 0x0034, 0x2ef: 0x0034,
+	0x2f0: 0x0034, 0x2f1: 0x0034, 0x2f2: 0x0034, 0x2f3: 0x0024, 0x2f4: 0x0024, 0x2f5: 0x0024,
+	0x2f6: 0x0034, 0x2f7: 0x0024, 0x2f8: 0x0024, 0x2f9: 0x0034, 0x2fa: 0x0034, 0x2fb: 0x0024,
+	0x2fc: 0x0024, 0x2fd: 0x0024, 0x2fe: 0x0024, 0x2ff: 0x0024,
+	// Block 0xc, offset 0x300
+	0x300: 0x7053, 0x301: 0x7053, 0x302: 0x7053, 0x303: 0x7053, 0x304: 0x7053, 0x305: 0x7053,
+	0x307: 0x7053,
+	0x30d: 0x7053, 0x310: 0x1bea, 0x311: 0x1c6a,
+	0x312: 0x1cea, 0x313: 0x1d6a, 0x314: 0x1dea, 0x315: 0x1e6a, 0x316: 0x1eea, 0x317: 0x1f6a,
+	0x318: 0x1fea, 0x319: 0x206a, 0x31a: 0x20ea, 0x31b: 0x216a, 0x31c: 0x21ea, 0x31d: 0x226a,
+	0x31e: 0x22ea, 0x31f: 0x236a, 0x320: 0x23ea, 0x321: 0x246a, 0x322: 0x24ea, 0x323: 0x256a,
+	0x324: 0x25ea, 0x325: 0x266a, 0x326: 0x26ea, 0x327: 0x276a, 0x328: 0x27ea, 0x329: 0x286a,
+	0x32a: 0x28ea, 0x32b: 0x296a, 0x32c: 0x29ea, 0x32d: 0x2a6a, 0x32e: 0x2aea, 0x32f: 0x2b6a,
+	0x330: 0x2bea, 0x331: 0x2c6a, 0x332: 0x2cea, 0x333: 0x2d6a, 0x334: 0x2dea, 0x335: 0x2e6a,
+	0x336: 0x2eea, 0x337: 0x2f6a, 0x338: 0x2fea, 0x339: 0x306a, 0x33a: 0x30ea,
+	0x33c: 0x0015, 0x33d: 0x316a, 0x33e: 0x31ea, 0x33f: 0x326a,
+	// Block 0xd, offset 0x340
+	0x340: 0x0812, 0x341: 0x0812, 0x342: 0x0812, 0x343: 0x0812, 0x344: 0x0812, 0x345: 0x0812,
+	0x348: 0x0813, 0x349: 0x0813, 0x34a: 0x0813, 0x34b: 0x0813,
+	0x34c: 0x0813, 0x34d: 0x0813, 0x350: 0x3c1a, 0x351: 0x0812,
+	0x352: 0x3cfa, 0x353: 0x0812, 0x354: 0x3e3a, 0x355: 0x0812, 0x356: 0x3f7a, 0x357: 0x0812,
+	0x359: 0x0813, 0x35b: 0x0813, 0x35d: 0x0813,
+	0x35f: 0x0813, 0x360: 0x0812, 0x361: 0x0812, 0x362: 0x0812, 0x363: 0x0812,
+	0x364: 0x0812, 0x365: 0x0812, 0x366: 0x0812, 0x367: 0x0812, 0x368: 0x0813, 0x369: 0x0813,
+	0x36a: 0x0813, 0x36b: 0x0813, 0x36c: 0x0813, 0x36d: 0x0813, 0x36e: 0x0813, 0x36f: 0x0813,
+	0x370: 0x9252, 0x371: 0x9252, 0x372: 0x9552, 0x373: 0x9552, 0x374: 0x9852, 0x375: 0x9852,
+	0x376: 0x9b52, 0x377: 0x9b52, 0x378: 0x9e52, 0x379: 0x9e52, 0x37a: 0xa152, 0x37b: 0xa152,
+	0x37c: 0x4d52, 0x37d: 0x4d52,
+	// Block 0xe, offset 0x380
+	0x380: 0x40ba, 0x381: 0x41aa, 0x382: 0x429a, 0x383: 0x438a, 0x384: 0x447a, 0x385: 0x456a,
+	0x386: 0x465a, 0x387: 0x474a, 0x388: 0x4839, 0x389: 0x4929, 0x38a: 0x4a19, 0x38b: 0x4b09,
+	0x38c: 0x4bf9, 0x38d: 0x4ce9, 0x38e: 0x4dd9, 0x38f: 0x4ec9, 0x390: 0x4fba, 0x391: 0x50aa,
+	0x392: 0x519a, 0x393: 0x528a, 0x394: 0x537a, 0x395: 0x546a, 0x396: 0x555a, 0x397: 0x564a,
+	0x398: 0x5739, 0x399: 0x5829, 0x39a: 0x5919, 0x39b: 0x5a09, 0x39c: 0x5af9, 0x39d: 0x5be9,
+	0x39e: 0x5cd9, 0x39f: 0x5dc9, 0x3a0: 0x5eba, 0x3a1: 0x5faa, 0x3a2: 0x609a, 0x3a3: 0x618a,
+	0x3a4: 0x627a, 0x3a5: 0x636a, 0x3a6: 0x645a, 0x3a7: 0x654a, 0x3a8: 0x6639, 0x3a9: 0x6729,
+	0x3aa: 0x6819, 0x3ab: 0x6909, 0x3ac: 0x69f9, 0x3ad: 0x6ae9, 0x3ae: 0x6bd9, 0x3af: 0x6cc9,
+	0x3b0: 0x0812, 0x3b1: 0x0812, 0x3b2: 0x6dba, 0x3b3: 0x6eca, 0x3b4: 0x6f9a,
+	0x3b6: 0x707a, 0x3b7: 0x715a, 0x3b8: 0x0813, 0x3b9: 0x0813, 0x3ba: 0x9253, 0x3bb: 0x9253,
+	0x3bc: 0x7299, 0x3bd: 0x0004, 0x3be: 0x736a, 0x3bf: 0x0004,
+	// Block 0xf, offset 0x3c0
+	0x3c0: 0x0004, 0x3c1: 0x0004, 0x3c2: 0x73ea, 0x3c3: 0x74fa, 0x3c4: 0x75ca,
+	0x3c6: 0x76aa, 0x3c7: 0x778a, 0x3c8: 0x9553, 0x3c9: 0x9553, 0x3ca: 0x9853, 0x3cb: 0x9853,
+	0x3cc: 0x78c9, 0x3cd: 0x0004, 0x3ce: 0x0004, 0x3cf: 0x0004, 0x3d0: 0x0812, 0x3d1: 0x0812,
+	0x3d2: 0x799a, 0x3d3: 0x7ada, 0x3d6: 0x7c1a, 0x3d7: 0x7cfa,
+	0x3d8: 0x0813, 0x3d9: 0x0813, 0x3da: 0x9b53, 0x3db: 0x9b53, 0x3dd: 0x0004,
+	0x3de: 0x0004, 0x3df: 0x0004, 0x3e0: 0x0812, 0x3e1: 0x0812, 0x3e2: 0x7e3a, 0x3e3: 0x7f7a,
+	0x3e4: 0x80ba, 0x3e5: 0x0912, 0x3e6: 0x819a, 0x3e7: 0x827a, 0x3e8: 0x0813, 0x3e9: 0x0813,
+	0x3ea: 0xa153, 0x3eb: 0xa153, 0x3ec: 0x0913, 0x3ed: 0x0004, 0x3ee: 0x0004, 0x3ef: 0x0004,
+	0x3f2: 0x83ba, 0x3f3: 0x84ca, 0x3f4: 0x859a,
+	0x3f6: 0x867a, 0x3f7: 0x875a, 0x3f8: 0x9e53, 0x3f9: 0x9e53, 0x3fa: 0x4d53, 0x3fb: 0x4d53,
+	0x3fc: 0x8899, 0x3fd: 0x0004, 0x3fe: 0x0004,
+	// Block 0x10, offset 0x400
+	0x402: 0x0013,
+	0x407: 0x0013, 0x40a: 0x0012, 0x40b: 0x0013,
+	0x40c: 0x0013, 0x40d: 0x0013, 0x40e: 0x0012, 0x40f: 0x0012, 0x410: 0x0013, 0x411: 0x0013,
+	0x412: 0x0013, 0x413: 0x0012, 0x415: 0x0013,
+	0x419: 0x0013, 0x41a: 0x0013, 0x41b: 0x0013, 0x41c: 0x0013, 0x41d: 0x0013,
+	0x424: 0x0013, 0x426: 0x896b, 0x428: 0x0013,
+	0x42a: 0x89cb, 0x42b: 0x8a0b, 0x42c: 0x0013, 0x42d: 0x0013, 0x42f: 0x0012,
+	0x430: 0x0013, 0x431: 0x0013, 0x432: 0xa453, 0x433: 0x0013, 0x434: 0x0012, 0x435: 0x0010,
+	0x436: 0x0010, 0x437: 0x0010, 0x438: 0x0010, 0x439: 0x0012,
+	0x43c: 0x0012, 0x43d: 0x0012, 0x43e: 0x0013, 0x43f: 0x0013,
+	// Block 0x11, offset 0x440
+	0x440: 0x1a13, 0x441: 0x1a13, 0x442: 0x1e13, 0x443: 0x1e13, 0x444: 0x1a13, 0x445: 0x1a13,
+	0x446: 0x2613, 0x447: 0x2613, 0x448: 0x2a13, 0x449: 0x2a13, 0x44a: 0x2e13, 0x44b: 0x2e13,
+	0x44c: 0x2a13, 0x44d: 0x2a13, 0x44e: 0x2613, 0x44f: 0x2613, 0x450: 0xa752, 0x451: 0xa752,
+	0x452: 0xaa52, 0x453: 0xaa52, 0x454: 0xad52, 0x455: 0xad52, 0x456: 0xaa52, 0x457: 0xaa52,
+	0x458: 0xa752, 0x459: 0xa752, 0x45a: 0x1a12, 0x45b: 0x1a12, 0x45c: 0x1e12, 0x45d: 0x1e12,
+	0x45e: 0x1a12, 0x45f: 0x1a12, 0x460: 0x2612, 0x461: 0x2612, 0x462: 0x2a12, 0x463: 0x2a12,
+	0x464: 0x2e12, 0x465: 0x2e12, 0x466: 0x2a12, 0x467: 0x2a12, 0x468: 0x2612, 0x469: 0x2612,
+	// Block 0x12, offset 0x480
+	0x480: 0x6552, 0x481: 0x6552, 0x482: 0x6552, 0x483: 0x6552, 0x484: 0x6552, 0x485: 0x6552,
+	0x486: 0x6552, 0x487: 0x6552, 0x488: 0x6552, 0x489: 0x6552, 0x48a: 0x6552, 0x48b: 0x6552,
+	0x48c: 0x6552, 0x48d: 0x6552, 0x48e: 0x6552, 0x48f: 0x6552, 0x490: 0xb052, 0x491: 0xb052,
+	0x492: 0xb052, 0x493: 0xb052, 0x494: 0xb052, 0x495: 0xb052, 0x496: 0xb052, 0x497: 0xb052,
+	0x498: 0xb052, 0x499: 0xb052, 0x49a: 0xb052, 0x49b: 0xb052, 0x49c: 0xb052, 0x49d: 0xb052,
+	0x49e: 0xb052, 0x49f: 0xb052, 0x4a0: 0x0113, 0x4a1: 0x0112, 0x4a2: 0x8a6b, 0x4a3: 0x8b53,
+	0x4a4: 0x8acb, 0x4a5: 0x8b2a, 0x4a6: 0x8b8a, 0x4a7: 0x0f13, 0x4a8: 0x0f12, 0x4a9: 0x0313,
+	0x4aa: 0x0312, 0x4ab: 0x0713, 0x4ac: 0x0712, 0x4ad: 0x8beb, 0x4ae: 0x8c4b, 0x4af: 0x8cab,
+	0x4b0: 0x8d0b, 0x4b1: 0x0012, 0x4b2: 0x0113, 0x4b3: 0x0112, 0x4b4: 0x0012, 0x4b5: 0x0313,
+	0x4b6: 0x0312, 0x4b7: 0x0012, 0x4b8: 0x0012, 0x4b9: 0x0012, 0x4ba: 0x0012, 0x4bb: 0x0012,
+	0x4bc: 0x0015, 0x4bd: 0x0015, 0x4be: 0x8d6b, 0x4bf: 0x8dcb,
+	// Block 0x13, offset 0x4c0
+	0x4c0: 0x0113, 0x4c1: 0x0112, 0x4c2: 0x0113, 0x4c3: 0x0112, 0x4c4: 0x0113, 0x4c5: 0x0112,
+	0x4c6: 0x0113, 0x4c7: 0x0112, 0x4c8: 0x0014, 0x4c9: 0x0014, 0x4ca: 0x0014, 0x4cb: 0x0713,
+	0x4cc: 0x0712, 0x4cd: 0x8e2b, 0x4ce: 0x0012, 0x4cf: 0x0010, 0x4d0: 0x0113, 0x4d1: 0x0112,
+	0x4d2: 0x0113, 0x4d3: 0x0112, 0x4d4: 0x6552, 0x4d5: 0x0012, 0x4d6: 0x0113, 0x4d7: 0x0112,
+	0x4d8: 0x0113, 0x4d9: 0x0112, 0x4da: 0x0113, 0x4db: 0x0112, 0x4dc: 0x0113, 0x4dd: 0x0112,
+	0x4de: 0x0113, 0x4df: 0x0112, 0x4e0: 0x0113, 0x4e1: 0x0112, 0x4e2: 0x0113, 0x4e3: 0x0112,
+	0x4e4: 0x0113, 0x4e5: 0x0112, 0x4e6: 0x0113, 0x4e7: 0x0112, 0x4e8: 0x0113, 0x4e9: 0x0112,
+	0x4ea: 0x8e8b, 0x4eb: 0x8eeb, 0x4ec: 0x8f4b, 0x4ed: 0x8fab, 0x4ee: 0x900b, 0x4ef: 0x0012,
+	0x4f0: 0x906b, 0x4f1: 0x90cb, 0x4f2: 0x912b, 0x4f3: 0xb353, 0x4f4: 0x0113, 0x4f5: 0x0112,
+	0x4f6: 0x0113, 0x4f7: 0x0112, 0x4f8: 0x0113, 0x4f9: 0x0112, 0x4fa: 0x0113, 0x4fb: 0x0112,
+	0x4fc: 0x0113, 0x4fd: 0x0112, 0x4fe: 0x0113, 0x4ff: 0x0112,
+	// Block 0x14, offset 0x500
+	0x500: 0x92aa, 0x501: 0x932a, 0x502: 0x93aa, 0x503: 0x942a, 0x504: 0x94da, 0x505: 0x958a,
+	0x506: 0x960a,
+	0x513: 0x968a, 0x514: 0x976a, 0x515: 0x984a, 0x516: 0x992a, 0x517: 0x9a0a,
+	0x51d: 0x0010,
+	0x51e: 0x0034, 0x51f: 0x0010, 0x520: 0x0010, 0x521: 0x0010, 0x522: 0x0010, 0x523: 0x0010,
+	0x524: 0x0010, 0x525: 0x0010, 0x526: 0x0010, 0x527: 0x0010, 0x528: 0x0010,
+	0x52a: 0x0010, 0x52b: 0x0010, 0x52c: 0x0010, 0x52d: 0x0010, 0x52e: 0x0010, 0x52f: 0x0010,
+	0x530: 0x0010, 0x531: 0x0010, 0x532: 0x0010, 0x533: 0x0010, 0x534: 0x0010, 0x535: 0x0010,
+	0x536: 0x0010, 0x538: 0x0010, 0x539: 0x0010, 0x53a: 0x0010, 0x53b: 0x0010,
+	0x53c: 0x0010, 0x53e: 0x0010,
+	// Block 0x15, offset 0x540
+	0x540: 0x2713, 0x541: 0x2913, 0x542: 0x2b13, 0x543: 0x2913, 0x544: 0x2f13, 0x545: 0x2913,
+	0x546: 0x2b13, 0x547: 0x2913, 0x548: 0x2713, 0x549: 0x3913, 0x54a: 0x3b13,
+	0x54c: 0x3f13, 0x54d: 0x3913, 0x54e: 0x3b13, 0x54f: 0x3913, 0x550: 0x2713, 0x551: 0x2913,
+	0x552: 0x2b13, 0x554: 0x2f13, 0x555: 0x2913, 0x557: 0xbc52,
+	0x558: 0xbf52, 0x559: 0xc252, 0x55a: 0xbf52, 0x55b: 0xc552, 0x55c: 0xbf52, 0x55d: 0xc252,
+	0x55e: 0xbf52, 0x55f: 0xbc52, 0x560: 0xc852, 0x561: 0xcb52, 0x563: 0xce52,
+	0x564: 0xc852, 0x565: 0xcb52, 0x566: 0xc852, 0x567: 0x2712, 0x568: 0x2912, 0x569: 0x2b12,
+	0x56a: 0x2912, 0x56b: 0x2f12, 0x56c: 0x2912, 0x56d: 0x2b12, 0x56e: 0x2912, 0x56f: 0x2712,
+	0x570: 0x3912, 0x571: 0x3b12, 0x573: 0x3f12, 0x574: 0x3912, 0x575: 0x3b12,
+	0x576: 0x3912, 0x577: 0x2712, 0x578: 0x2912, 0x579: 0x2b12, 0x57b: 0x2f12,
+	0x57c: 0x2912,
+	// Block 0x16, offset 0x580
+	0x5a0: 0x1b13, 0x5a1: 0x1d13, 0x5a2: 0x1f13, 0x5a3: 0x1d13,
+	0x5a4: 0x1b13, 0x5a5: 0xd453, 0x5a6: 0xd753, 0x5a7: 0xd453, 0x5a8: 0xda53, 0x5a9: 0xdd53,
+	0x5aa: 0xe053, 0x5ab: 0xdd53, 0x5ac: 0xda53, 0x5ad: 0xd453, 0x5ae: 0xd753, 0x5af: 0xd453,
+	0x5b0: 0xe353, 0x5b1: 0xe653, 0x5b2: 0x0553, 0x5b3: 0xe653, 0x5b4: 0xe353, 0x5b5: 0xd453,
+	0x5b6: 0xd753, 0x5b7: 0xd453, 0x5b8: 0xda53, 0x5bb: 0x1b12,
+	0x5bc: 0x1d12, 0x5bd: 0x1f12, 0x5be: 0x1d12, 0x5bf: 0x1b12,
+	// Block 0x17, offset 0x5c0
+	0x5c0: 0xd452, 0x5c1: 0xd752, 0x5c2: 0xd452, 0x5c3: 0xda52, 0x5c4: 0xdd52, 0x5c5: 0xe052,
+	0x5c6: 0xdd52, 0x5c7: 0xda52, 0x5c8: 0xd452, 0x5c9: 0xd752, 0x5ca: 0xd452, 0x5cb: 0xe352,
+	0x5cc: 0xe652, 0x5cd: 0x0552, 0x5ce: 0xe652, 0x5cf: 0xe352, 0x5d0: 0xd452, 0x5d1: 0xd752,
+	0x5d2: 0xd452, 0x5d3: 0xda52,
+	// Block 0x18, offset 0x600
+	0x600: 0x2213, 0x601: 0x2213, 0x602: 0x2613, 0x603: 0x2613, 0x604: 0x2213, 0x605: 0x2213,
+	0x606: 0x2e13, 0x607: 0x2e13, 0x608: 0x2213, 0x609: 0x2213, 0x60a: 0x2613, 0x60b: 0x2613,
+	0x60c: 0x2213, 0x60d: 0x2213, 0x60e: 0x3e13, 0x60f: 0x3e13, 0x610: 0x2213, 0x611: 0x2213,
+	0x612: 0x2613, 0x613: 0x2613, 0x614: 0x2213, 0x615: 0x2213, 0x616: 0x2e13, 0x617: 0x2e13,
+	0x618: 0x2213, 0x619: 0x2213, 0x61a: 0x2613, 0x61b: 0x2613, 0x61c: 0x2213, 0x61d: 0x2213,
+	0x61e: 0xe953, 0x61f: 0xe953, 0x620: 0xec53, 0x621: 0xec53, 0x622: 0x2212, 0x623: 0x2212,
+	0x624: 0x2612, 0x625: 0x2612, 0x626: 0x2212, 0x627: 0x2212, 0x628: 0x2e12, 0x629: 0x2e12,
+	0x62a: 0x2212, 0x62b: 0x2212, 0x62c: 0x2612, 0x62d: 0x2612, 0x62e: 0x2212, 0x62f: 0x2212,
+	0x630: 0x3e12, 0x631: 0x3e12, 0x632: 0x2212, 0x633: 0x2212, 0x634: 0x2612, 0x635: 0x2612,
+	0x636: 0x2212, 0x637: 0x2212, 0x638: 0x2e12, 0x639: 0x2e12, 0x63a: 0x2212, 0x63b: 0x2212,
+	0x63c: 0x2612, 0x63d: 0x2612, 0x63e: 0x2212, 0x63f: 0x2212,
+	// Block 0x19, offset 0x640
+	0x642: 0x0010,
+	0x647: 0x0010, 0x649: 0x0010, 0x64b: 0x0010,
+	0x64d: 0x0010, 0x64e: 0x0010, 0x64f: 0x0010, 0x651: 0x0010,
+	0x652: 0x0010, 0x654: 0x0010, 0x657: 0x0010,
+	0x659: 0x0010, 0x65b: 0x0010, 0x65d: 0x0010,
+	0x65f: 0x0010, 0x661: 0x0010, 0x662: 0x0010,
+	0x664: 0x0010, 0x667: 0x0010, 0x668: 0x0010, 0x669: 0x0010,
+	0x66a: 0x0010, 0x66c: 0x0010, 0x66d: 0x0010, 0x66e: 0x0010, 0x66f: 0x0010,
+	0x670: 0x0010, 0x671: 0x0010, 0x672: 0x0010, 0x674: 0x0010, 0x675: 0x0010,
+	0x676: 0x0010, 0x677: 0x0010, 0x679: 0x0010, 0x67a: 0x0010, 0x67b: 0x0010,
+	0x67c: 0x0010, 0x67e: 0x0010,
+}
+
+// caseIndex: 27 blocks, 1728 entries, 3456 bytes
+// Block 0 is the zero block.
+var caseIndex = [1728]uint16{
+	// Block 0x0, offset 0x0
+	// Block 0x1, offset 0x40
+	// Block 0x2, offset 0x80
+	// Block 0x3, offset 0xc0
+	0xc2: 0x18, 0xc3: 0x19, 0xc4: 0x1a, 0xc5: 0x1b, 0xc6: 0x01, 0xc7: 0x02,
+	0xc8: 0x1c, 0xc9: 0x03, 0xca: 0x04, 0xcb: 0x1d, 0xcc: 0x1e, 0xcd: 0x05, 0xce: 0x06, 0xcf: 0x07,
+	0xd0: 0x1f, 0xd1: 0x20, 0xd2: 0x21, 0xd3: 0x22, 0xd4: 0x23, 0xd5: 0x24, 0xd6: 0x08, 0xd7: 0x25,
+	0xd8: 0x26, 0xd9: 0x27, 0xda: 0x28, 0xdb: 0x29, 0xdc: 0x2a, 0xdd: 0x2b, 0xde: 0x2c, 0xdf: 0x2d,
+	0xe0: 0x02, 0xe1: 0x03, 0xe2: 0x04, 0xe3: 0x05,
+	0xea: 0x06, 0xeb: 0x07, 0xec: 0x07, 0xed: 0x08, 0xef: 0x09,
+	0xf0: 0x16, 0xf3: 0x18,
+	// Block 0x4, offset 0x100
+	0x120: 0x2e, 0x121: 0x2f, 0x122: 0x30, 0x123: 0x09, 0x124: 0x31, 0x125: 0x32, 0x126: 0x33, 0x127: 0x34,
+	0x128: 0x35, 0x129: 0x36, 0x12a: 0x37, 0x12b: 0x38, 0x12c: 0x39, 0x12d: 0x3a, 0x12e: 0x3b, 0x12f: 0x3c,
+	0x130: 0x3d, 0x131: 0x3e, 0x132: 0x3f, 0x133: 0x40, 0x134: 0x41, 0x135: 0x42, 0x136: 0x43, 0x137: 0x44,
+	0x138: 0x45, 0x139: 0x46, 0x13a: 0x47, 0x13b: 0x48, 0x13c: 0x49, 0x13d: 0x4a, 0x13e: 0x4b, 0x13f: 0x4c,
+	// Block 0x5, offset 0x140
+	0x140: 0x4d, 0x141: 0x4e, 0x142: 0x4f, 0x143: 0x0a, 0x144: 0x28, 0x145: 0x28, 0x146: 0x28, 0x147: 0x28,
+	0x148: 0x28, 0x149: 0x50, 0x14a: 0x51, 0x14b: 0x52, 0x14c: 0x53, 0x14d: 0x54, 0x14e: 0x55, 0x14f: 0x56,
+	0x150: 0x57, 0x151: 0x28, 0x152: 0x28, 0x153: 0x28, 0x154: 0x28, 0x155: 0x28, 0x156: 0x28, 0x157: 0x28,
+	0x158: 0x28, 0x159: 0x58, 0x15a: 0x59, 0x15b: 0x5a, 0x15c: 0x5b, 0x15d: 0x5c, 0x15e: 0x5d, 0x15f: 0x5e,
+	0x160: 0x5f, 0x161: 0x60, 0x162: 0x61, 0x163: 0x62, 0x164: 0x63, 0x165: 0x64, 0x167: 0x65,
+	0x168: 0x66, 0x169: 0x67, 0x16a: 0x68, 0x16b: 0x69, 0x16c: 0x6a, 0x16d: 0x6b, 0x16e: 0x6c, 0x16f: 0x6d,
+	0x170: 0x6e, 0x171: 0x6f, 0x172: 0x70, 0x173: 0x71, 0x174: 0x72, 0x175: 0x73, 0x176: 0x74, 0x177: 0x75,
+	0x178: 0x76, 0x179: 0x76, 0x17a: 0x77, 0x17b: 0x76, 0x17c: 0x78, 0x17d: 0x0b, 0x17e: 0x0c, 0x17f: 0x0d,
+	// Block 0x6, offset 0x180
+	0x180: 0x79, 0x181: 0x7a, 0x182: 0x7b, 0x183: 0x7c, 0x184: 0x0e, 0x185: 0x7d, 0x186: 0x7e,
+	0x192: 0x7f, 0x193: 0x0f,
+	0x1b0: 0x80, 0x1b1: 0x10, 0x1b2: 0x76, 0x1b3: 0x81, 0x1b4: 0x82, 0x1b5: 0x83, 0x1b6: 0x84, 0x1b7: 0x85,
+	0x1b8: 0x86,
+	// Block 0x7, offset 0x1c0
+	0x1c0: 0x87, 0x1c2: 0x88, 0x1c3: 0x89, 0x1c4: 0x8a, 0x1c5: 0x28, 0x1c6: 0x8b,
+	// Block 0x8, offset 0x200
+	0x200: 0x8c, 0x201: 0x28, 0x202: 0x28, 0x203: 0x28, 0x204: 0x28, 0x205: 0x28, 0x206: 0x28, 0x207: 0x28,
+	0x208: 0x28, 0x209: 0x28, 0x20a: 0x28, 0x20b: 0x28, 0x20c: 0x28, 0x20d: 0x28, 0x20e: 0x28, 0x20f: 0x28,
+	0x210: 0x28, 0x211: 0x28, 0x212: 0x8d, 0x213: 0x8e, 0x214: 0x28, 0x215: 0x28, 0x216: 0x28, 0x217: 0x28,
+	0x218: 0x8f, 0x219: 0x90, 0x21a: 0x91, 0x21b: 0x92, 0x21c: 0x93, 0x21d: 0x94, 0x21e: 0x11, 0x21f: 0x95,
+	0x220: 0x96, 0x221: 0x97, 0x222: 0x28, 0x223: 0x98, 0x224: 0x99, 0x225: 0x9a, 0x226: 0x9b, 0x227: 0x9c,
+	0x228: 0x9d, 0x229: 0x9e, 0x22a: 0x9f, 0x22b: 0xa0, 0x22c: 0xa1, 0x22d: 0xa2, 0x22e: 0xa3, 0x22f: 0xa4,
+	0x230: 0x28, 0x231: 0x28, 0x232: 0x28, 0x233: 0x28, 0x234: 0x28, 0x235: 0x28, 0x236: 0x28, 0x237: 0x28,
+	0x238: 0x28, 0x239: 0x28, 0x23a: 0x28, 0x23b: 0x28, 0x23c: 0x28, 0x23d: 0x28, 0x23e: 0x28, 0x23f: 0x28,
+	// Block 0x9, offset 0x240
+	0x240: 0x28, 0x241: 0x28, 0x242: 0x28, 0x243: 0x28, 0x244: 0x28, 0x245: 0x28, 0x246: 0x28, 0x247: 0x28,
+	0x248: 0x28, 0x249: 0x28, 0x24a: 0x28, 0x24b: 0x28, 0x24c: 0x28, 0x24d: 0x28, 0x24e: 0x28, 0x24f: 0x28,
+	0x250: 0x28, 0x251: 0x28, 0x252: 0x28, 0x253: 0x28, 0x254: 0x28, 0x255: 0x28, 0x256: 0x28, 0x257: 0x28,
+	0x258: 0x28, 0x259: 0x28, 0x25a: 0x28, 0x25b: 0x28, 0x25c: 0x28, 0x25d: 0x28, 0x25e: 0x28, 0x25f: 0x28,
+	0x260: 0x28, 0x261: 0x28, 0x262: 0x28, 0x263: 0x28, 0x264: 0x28, 0x265: 0x28, 0x266: 0x28, 0x267: 0x28,
+	0x268: 0x28, 0x269: 0x28, 0x26a: 0x28, 0x26b: 0x28, 0x26c: 0x28, 0x26d: 0x28, 0x26e: 0x28, 0x26f: 0x28,
+	0x270: 0x28, 0x271: 0x28, 0x272: 0x28, 0x273: 0x28, 0x274: 0x28, 0x275: 0x28, 0x276: 0x28, 0x277: 0x28,
+	0x278: 0x28, 0x279: 0x28, 0x27a: 0x28, 0x27b: 0x28, 0x27c: 0x28, 0x27d: 0x28, 0x27e: 0x28, 0x27f: 0x28,
+	// Block 0xa, offset 0x280
+	0x280: 0x28, 0x281: 0x28, 0x282: 0x28, 0x283: 0x28, 0x284: 0x28, 0x285: 0x28, 0x286: 0x28, 0x287: 0x28,
+	0x288: 0x28, 0x289: 0x28, 0x28a: 0x28, 0x28b: 0x28, 0x28c: 0x28, 0x28d: 0x28, 0x28e: 0x28, 0x28f: 0x28,
+	0x290: 0x28, 0x291: 0x28, 0x292: 0x28, 0x293: 0x28, 0x294: 0x28, 0x295: 0x28, 0x296: 0x28, 0x297: 0x28,
+	0x298: 0x28, 0x299: 0x28, 0x29a: 0x28, 0x29b: 0x28, 0x29c: 0x28, 0x29d: 0x28, 0x29e: 0xa5, 0x29f: 0xa6,
+	// Block 0xb, offset 0x2c0
+	0x2ec: 0x12, 0x2ed: 0xa7, 0x2ee: 0xa8, 0x2ef: 0xa9,
+	0x2f0: 0x28, 0x2f1: 0x28, 0x2f2: 0x28, 0x2f3: 0x28, 0x2f4: 0xaa, 0x2f5: 0xab, 0x2f6: 0xac, 0x2f7: 0xad,
+	0x2f8: 0xae, 0x2f9: 0xaf, 0x2fa: 0x28, 0x2fb: 0xb0, 0x2fc: 0xb1, 0x2fd: 0xb2, 0x2fe: 0xb3, 0x2ff: 0xb4,
+	// Block 0xc, offset 0x300
+	0x300: 0xb5, 0x301: 0xb6, 0x302: 0x28, 0x303: 0xb7, 0x305: 0xb8, 0x307: 0xb9,
+	0x30a: 0xba, 0x30b: 0xbb, 0x30c: 0xbc, 0x30d: 0xbd, 0x30e: 0xbe, 0x30f: 0xbf,
+	0x310: 0xc0, 0x311: 0xc1, 0x312: 0xc2, 0x313: 0xc3, 0x314: 0xc4, 0x315: 0xc5, 0x316: 0x13, 0x317: 0x97,
+	0x318: 0x28, 0x319: 0x28, 0x31a: 0x28, 0x31b: 0x28, 0x31c: 0xc6, 0x31d: 0xc7, 0x31e: 0xc8,
+	0x320: 0xc9, 0x321: 0xca, 0x322: 0xcb, 0x323: 0xcc, 0x324: 0xcd, 0x325: 0xce, 0x326: 0xcf,
+	0x328: 0xd0, 0x329: 0xd1, 0x32a: 0xd2, 0x32b: 0xd3, 0x32c: 0x62, 0x32d: 0xd4, 0x32e: 0xd5,
+	0x330: 0x28, 0x331: 0xd6, 0x332: 0xd7, 0x333: 0xd8, 0x334: 0xd9, 0x335: 0xda, 0x336: 0xdb,
+	0x33a: 0xdc, 0x33b: 0xdd, 0x33c: 0xde, 0x33d: 0xdf, 0x33e: 0xe0, 0x33f: 0xe1,
+	// Block 0xd, offset 0x340
+	0x340: 0xe2, 0x341: 0xe3, 0x342: 0xe4, 0x343: 0xe5, 0x344: 0xe6, 0x345: 0xe7, 0x346: 0xe8, 0x347: 0xe9,
+	0x348: 0xea, 0x349: 0xeb, 0x34a: 0xec, 0x34b: 0xed, 0x34c: 0xee, 0x34d: 0xef, 0x34e: 0xf0, 0x34f: 0xf1,
+	0x350: 0xf2, 0x351: 0xf3, 0x352: 0xf4, 0x353: 0xf5, 0x356: 0xf6, 0x357: 0xf7,
+	0x358: 0xf8, 0x359: 0xf9, 0x35a: 0xfa, 0x35b: 0xfb, 0x35c: 0xfc,
+	0x360: 0xfd, 0x362: 0xfe, 0x363: 0xff, 0x364: 0x100, 0x365: 0x101, 0x366: 0x102, 0x367: 0x103,
+	0x368: 0x104, 0x369: 0x105, 0x36a: 0x106, 0x36b: 0x107, 0x36d: 0x108, 0x36f: 0x109,
+	0x370: 0x10a, 0x371: 0x10b, 0x372: 0x10c, 0x374: 0x10d, 0x375: 0x10e, 0x376: 0x10f, 0x377: 0x110,
+	0x37b: 0x111, 0x37c: 0x112, 0x37d: 0x113, 0x37e: 0x114,
+	// Block 0xe, offset 0x380
+	0x380: 0x28, 0x381: 0x28, 0x382: 0x28, 0x383: 0x28, 0x384: 0x28, 0x385: 0x28, 0x386: 0x28, 0x387: 0x28,
+	0x388: 0x28, 0x389: 0x28, 0x38a: 0x28, 0x38b: 0x28, 0x38c: 0x28, 0x38d: 0x28, 0x38e: 0xce,
+	0x390: 0x28, 0x391: 0x115, 0x392: 0x28, 0x393: 0x28, 0x394: 0x28, 0x395: 0x116,
+	0x3be: 0xab, 0x3bf: 0x117,
+	// Block 0xf, offset 0x3c0
+	0x3c0: 0x28, 0x3c1: 0x28, 0x3c2: 0x28, 0x3c3: 0x28, 0x3c4: 0x28, 0x3c5: 0x28, 0x3c6: 0x28, 0x3c7: 0x28,
+	0x3c8: 0x28, 0x3c9: 0x28, 0x3ca: 0x28, 0x3cb: 0x28, 0x3cc: 0x28, 0x3cd: 0x28, 0x3ce: 0x28, 0x3cf: 0x28,
+	0x3d0: 0x118, 0x3d1: 0x119, 0x3d2: 0x28, 0x3d3: 0x28, 0x3d4: 0x28, 0x3d5: 0x28, 0x3d6: 0x28, 0x3d7: 0x28,
+	0x3d8: 0x28, 0x3d9: 0x28, 0x3da: 0x28, 0x3db: 0x28, 0x3dc: 0x28, 0x3dd: 0x28, 0x3de: 0x28, 0x3df: 0x28,
+	0x3e0: 0x28, 0x3e1: 0x28, 0x3e2: 0x28, 0x3e3: 0x28, 0x3e4: 0x28, 0x3e5: 0x28, 0x3e6: 0x28, 0x3e7: 0x28,
+	0x3e8: 0x28, 0x3e9: 0x28, 0x3ea: 0x28, 0x3eb: 0x28, 0x3ec: 0x28, 0x3ed: 0x28, 0x3ee: 0x28, 0x3ef: 0x28,
+	0x3f0: 0x28, 0x3f1: 0x28, 0x3f2: 0x28, 0x3f3: 0x28, 0x3f4: 0x28, 0x3f5: 0x28, 0x3f6: 0x28, 0x3f7: 0x28,
+	0x3f8: 0x28, 0x3f9: 0x28, 0x3fa: 0x28, 0x3fb: 0x28, 0x3fc: 0x28, 0x3fd: 0x28, 0x3fe: 0x28, 0x3ff: 0x28,
+	// Block 0x10, offset 0x400
+	0x400: 0x28, 0x401: 0x28, 0x402: 0x28, 0x403: 0x28, 0x404: 0x28, 0x405: 0x28, 0x406: 0x28, 0x407: 0x28,
+	0x408: 0x28, 0x409: 0x28, 0x40a: 0x28, 0x40b: 0x28, 0x40c: 0x28, 0x40d: 0x28, 0x40e: 0x28, 0x40f: 0xb7,
+	0x410: 0x28, 0x411: 0x28, 0x412: 0x28, 0x413: 0x28, 0x414: 0x28, 0x415: 0x28, 0x416: 0x28, 0x417: 0x28,
+	0x418: 0x28, 0x419: 0x11a,
+	// Block 0x11, offset 0x440
+	0x444: 0x11b,
+	0x460: 0x28, 0x461: 0x28, 0x462: 0x28, 0x463: 0x28, 0x464: 0x28, 0x465: 0x28, 0x466: 0x28, 0x467: 0x28,
+	0x468: 0x107, 0x469: 0x11c, 0x46a: 0x11d, 0x46b: 0x11e, 0x46c: 0x11f, 0x46d: 0x120, 0x46e: 0x121,
+	0x475: 0x122,
+	0x479: 0x123, 0x47a: 0x14, 0x47b: 0x15, 0x47c: 0x28, 0x47d: 0x124, 0x47e: 0x125, 0x47f: 0x126,
+	// Block 0x12, offset 0x480
+	0x4bf: 0x127,
+	// Block 0x13, offset 0x4c0
+	0x4f0: 0x28, 0x4f1: 0x128, 0x4f2: 0x129,
+	// Block 0x14, offset 0x500
+	0x533: 0x12a,
+	0x53c: 0x12b, 0x53d: 0x12c,
+	// Block 0x15, offset 0x540
+	0x545: 0x12d, 0x546: 0x12e,
+	0x549: 0x12f,
+	0x550: 0x130, 0x551: 0x131, 0x552: 0x132, 0x553: 0x133, 0x554: 0x134, 0x555: 0x135, 0x556: 0x136, 0x557: 0x137,
+	0x558: 0x138, 0x559: 0x139, 0x55a: 0x13a, 0x55b: 0x13b, 0x55c: 0x13c, 0x55d: 0x13d, 0x55e: 0x13e, 0x55f: 0x13f,
+	0x568: 0x140, 0x569: 0x141, 0x56a: 0x142,
+	0x57c: 0x143,
+	// Block 0x16, offset 0x580
+	0x580: 0x144, 0x581: 0x145, 0x582: 0x146, 0x584: 0x147, 0x585: 0x148,
+	0x58a: 0x149, 0x58b: 0x14a,
+	0x593: 0x14b, 0x597: 0x14c,
+	0x59b: 0x14d, 0x59f: 0x14e,
+	0x5a0: 0x28, 0x5a1: 0x28, 0x5a2: 0x28, 0x5a3: 0x14f, 0x5a4: 0x16, 0x5a5: 0x150,
+	0x5b8: 0x151, 0x5b9: 0x17, 0x5ba: 0x152,
+	// Block 0x17, offset 0x5c0
+	0x5c4: 0x153, 0x5c5: 0x154, 0x5c6: 0x155,
+	0x5cf: 0x156,
+	0x5ef: 0x12a,
+	// Block 0x18, offset 0x600
+	0x610: 0x0a, 0x611: 0x0b, 0x612: 0x0c, 0x613: 0x0d, 0x614: 0x0e, 0x616: 0x0f,
+	0x61a: 0x10, 0x61b: 0x11, 0x61c: 0x12, 0x61d: 0x13, 0x61e: 0x14, 0x61f: 0x15,
+	// Block 0x19, offset 0x640
+	0x640: 0x157, 0x641: 0x158, 0x644: 0x158, 0x645: 0x158, 0x646: 0x158, 0x647: 0x159,
+	// Block 0x1a, offset 0x680
+	0x6a0: 0x17,
+}
+
+// sparseOffsets: 323 entries, 646 bytes
+var sparseOffsets = []uint16{0x0, 0x9, 0xf, 0x18, 0x24, 0x2e, 0x34, 0x37, 0x3b, 0x3e, 0x42, 0x4c, 0x4e, 0x57, 0x5e, 0x63, 0x71, 0x72, 0x80, 0x8f, 0x99, 0x9c, 0xa3, 0xab, 0xaf, 0xb7, 0xbd, 0xcb, 0xd6, 0xe3, 0xee, 0xfa, 0x104, 0x110, 0x11b, 0x127, 0x133, 0x13b, 0x145, 0x150, 0x15b, 0x167, 0x16d, 0x178, 0x17e, 0x186, 0x189, 0x18e, 0x192, 0x196, 0x19d, 0x1a6, 0x1ae, 0x1af, 0x1b8, 0x1bf, 0x1c7, 0x1cd, 0x1d2, 0x1d6, 0x1d9, 0x1db, 0x1de, 0x1e3, 0x1e4, 0x1e6, 0x1e8, 0x1ea, 0x1f1, 0x1f6, 0x1fa, 0x203, 0x206, 0x209, 0x20f, 0x210, 0x21b, 0x21c, 0x21d, 0x222, 0x22f, 0x238, 0x243, 0x24b, 0x254, 0x25d, 0x266, 0x26b, 0x26e, 0x27a, 0x288, 0x28a, 0x291, 0x295, 0x2a1, 0x2a2, 0x2ad, 0x2b5, 0x2bd, 0x2c3, 0x2c4, 0x2d2, 0x2d7, 0x2da, 0x2df, 0x2e3, 0x2e9, 0x2ee, 0x2f1, 0x2f6, 0x2fb, 0x2fc, 0x302, 0x304, 0x305, 0x307, 0x309, 0x30c, 0x30d, 0x30f, 0x312, 0x318, 0x31c, 0x31e, 0x323, 0x32a, 0x339, 0x343, 0x344, 0x34d, 0x351, 0x356, 0x35e, 0x364, 0x36a, 0x374, 0x379, 0x382, 0x388, 0x391, 0x395, 0x39d, 0x39f, 0x3a1, 0x3a4, 0x3a6, 0x3a8, 0x3a9, 0x3aa, 0x3ac, 0x3ae, 0x3b4, 0x3b9, 0x3bb, 0x3c2, 0x3c5, 0x3c7, 0x3cd, 0x3d2, 0x3d4, 0x3d5, 0x3d6, 0x3d7, 0x3d9, 0x3db, 0x3dd, 0x3e0, 0x3e2, 0x3e5, 0x3ed, 0x3f0, 0x3f4, 0x3fc, 0x3fe, 0x40e, 0x40f, 0x411, 0x416, 0x41c, 0x41e, 0x41f, 0x421, 0x423, 0x424, 0x426, 0x433, 0x434, 0x435, 0x439, 0x43b, 0x43c, 0x43d, 0x43e, 0x43f, 0x442, 0x44a, 0x44b, 0x44e, 0x454, 0x457, 0x45e, 0x464, 0x466, 0x46a, 0x472, 0x478, 0x47c, 0x483, 0x487, 0x48b, 0x494, 0x49e, 0x4a0, 0x4a6, 0x4ac, 0x4b6, 0x4c0, 0x4c6, 0x4d2, 0x4d4, 0x4dd, 0x4e3, 0x4e9, 0x4ef, 0x4f2, 0x4f8, 0x4fb, 0x504, 0x506, 0x50f, 0x513, 0x514, 0x517, 0x521, 0x524, 0x526, 0x52d, 0x535, 0x53b, 0x542, 0x543, 0x549, 0x54b, 0x551, 0x554, 0x55c, 0x563, 0x56d, 0x576, 0x57a, 0x57d, 0x582, 0x587, 0x588, 0x589, 0x58a, 0x58b, 0x58d, 0x591, 0x592, 0x598, 0x59b, 0x59c, 0x59f, 0x5a1, 0x5a5, 0x5a6, 0x5aa, 0x5ac, 0x5af, 0x5b1, 0x5b5, 0x5b8, 0x5ba, 0x5bf, 0x5c0, 0x5c2, 0x5c3, 0x5c8, 0x5cc, 0x5cd, 0x5d0, 0x5d4, 0x5df, 0x5e3, 0x5eb, 0x5f0, 0x5f4, 0x5f7, 0x5fb, 0x5fe, 0x601, 0x606, 0x60a, 0x60e, 0x612, 0x616, 0x618, 0x61a, 0x61d, 0x621, 0x627, 0x628, 0x629, 0x62c, 0x62e, 0x630, 0x633, 0x638, 0x63c, 0x647, 0x64b, 0x64d, 0x653, 0x65c, 0x661, 0x662, 0x665, 0x666, 0x667, 0x669, 0x66a, 0x66b}
+
+// sparseValues: 1643 entries, 6572 bytes
+var sparseValues = [1643]valueRange{
+	// Block 0x0, offset 0x0
+	{value: 0x0004, lo: 0xa8, hi: 0xa8},
+	{value: 0x0012, lo: 0xaa, hi: 0xaa},
+	{value: 0x0014, lo: 0xad, hi: 0xad},
+	{value: 0x0004, lo: 0xaf, hi: 0xaf},
+	{value: 0x0004, lo: 0xb4, hi: 0xb4},
+	{value: 0x001a, lo: 0xb5, hi: 0xb5},
+	{value: 0x0054, lo: 0xb7, hi: 0xb7},
+	{value: 0x0014, lo: 0xb8, hi: 0xb8},
+	{value: 0x0012, lo: 0xba, hi: 0xba},
+	// Block 0x1, offset 0x9
+	{value: 0x2013, lo: 0x80, hi: 0x96},
+	{value: 0x2013, lo: 0x98, hi: 0x9e},
+	{value: 0x009a, lo: 0x9f, hi: 0x9f},
+	{value: 0x2012, lo: 0xa0, hi: 0xb6},
+	{value: 0x2012, lo: 0xb8, hi: 0xbe},
+	{value: 0x0252, lo: 0xbf, hi: 0xbf},
+	// Block 0x2, offset 0xf
+	{value: 0x0117, lo: 0x80, hi: 0xaf},
+	{value: 0x011b, lo: 0xb0, hi: 0xb0},
+	{value: 0x019a, lo: 0xb1, hi: 0xb1},
+	{value: 0x0117, lo: 0xb2, hi: 0xb7},
+	{value: 0x0012, lo: 0xb8, hi: 0xb8},
+	{value: 0x0316, lo: 0xb9, hi: 0xba},
+	{value: 0x0716, lo: 0xbb, hi: 0xbc},
+	{value: 0x0316, lo: 0xbd, hi: 0xbe},
+	{value: 0x0553, lo: 0xbf, hi: 0xbf},
+	// Block 0x3, offset 0x18
+	{value: 0x0552, lo: 0x80, hi: 0x80},
+	{value: 0x0316, lo: 0x81, hi: 0x82},
+	{value: 0x0716, lo: 0x83, hi: 0x84},
+	{value: 0x0316, lo: 0x85, hi: 0x86},
+	{value: 0x0f16, lo: 0x87, hi: 0x88},
+	{value: 0x01da, lo: 0x89, hi: 0x89},
+	{value: 0x0117, lo: 0x8a, hi: 0xb7},
+	{value: 0x0253, lo: 0xb8, hi: 0xb8},
+	{value: 0x0316, lo: 0xb9, hi: 0xba},
+	{value: 0x0716, lo: 0xbb, hi: 0xbc},
+	{value: 0x0316, lo: 0xbd, hi: 0xbe},
+	{value: 0x028a, lo: 0xbf, hi: 0xbf},
+	// Block 0x4, offset 0x24
+	{value: 0x0117, lo: 0x80, hi: 0x9f},
+	{value: 0x2f53, lo: 0xa0, hi: 0xa0},
+	{value: 0x0012, lo: 0xa1, hi: 0xa1},
+	{value: 0x0117, lo: 0xa2, hi: 0xb3},
+	{value: 0x0012, lo: 0xb4, hi: 0xb9},
+	{value: 0x098b, lo: 0xba, hi: 0xba},
+	{value: 0x0716, lo: 0xbb, hi: 0xbc},
+	{value: 0x2953, lo: 0xbd, hi: 0xbd},
+	{value: 0x0a0b, lo: 0xbe, hi: 0xbe},
+	{value: 0x0a8a, lo: 0xbf, hi: 0xbf},
+	// Block 0x5, offset 0x2e
+	{value: 0x0015, lo: 0x80, hi: 0x81},
+	{value: 0x0014, lo: 0x82, hi: 0x97},
+	{value: 0x0004, lo: 0x98, hi: 0x9d},
+	{value: 0x0014, lo: 0x9e, hi: 0x9f},
+	{value: 0x0015, lo: 0xa0, hi: 0xa4},
+	{value: 0x0014, lo: 0xa5, hi: 0xbf},
+	// Block 0x6, offset 0x34
+	{value: 0x0024, lo: 0x80, hi: 0x94},
+	{value: 0x0034, lo: 0x95, hi: 0xbc},
+	{value: 0x0024, lo: 0xbd, hi: 0xbf},
+	// Block 0x7, offset 0x37
+	{value: 0x6553, lo: 0x80, hi: 0x8f},
+	{value: 0x2013, lo: 0x90, hi: 0x9f},
+	{value: 0x5f53, lo: 0xa0, hi: 0xaf},
+	{value: 0x2012, lo: 0xb0, hi: 0xbf},
+	// Block 0x8, offset 0x3b
+	{value: 0x5f52, lo: 0x80, hi: 0x8f},
+	{value: 0x6552, lo: 0x90, hi: 0x9f},
+	{value: 0x0117, lo: 0xa0, hi: 0xbf},
+	// Block 0x9, offset 0x3e
+	{value: 0x0117, lo: 0x80, hi: 0x81},
+	{value: 0x0024, lo: 0x83, hi: 0x87},
+	{value: 0x0014, lo: 0x88, hi: 0x89},
+	{value: 0x0117, lo: 0x8a, hi: 0xbf},
+	// Block 0xa, offset 0x42
+	{value: 0x0f13, lo: 0x80, hi: 0x80},
+	{value: 0x0316, lo: 0x81, hi: 0x82},
+	{value: 0x0716, lo: 0x83, hi: 0x84},
+	{value: 0x0316, lo: 0x85, hi: 0x86},
+	{value: 0x0f16, lo: 0x87, hi: 0x88},
+	{value: 0x0316, lo: 0x89, hi: 0x8a},
+	{value: 0x0716, lo: 0x8b, hi: 0x8c},
+	{value: 0x0316, lo: 0x8d, hi: 0x8e},
+	{value: 0x0f12, lo: 0x8f, hi: 0x8f},
+	{value: 0x0117, lo: 0x90, hi: 0xbf},
+	// Block 0xb, offset 0x4c
+	{value: 0x0117, lo: 0x80, hi: 0xaf},
+	{value: 0x6553, lo: 0xb1, hi: 0xbf},
+	// Block 0xc, offset 0x4e
+	{value: 0x3013, lo: 0x80, hi: 0x8f},
+	{value: 0x6853, lo: 0x90, hi: 0x96},
+	{value: 0x0014, lo: 0x99, hi: 0x99},
+	{value: 0x0010, lo: 0x9a, hi: 0x9c},
+	{value: 0x0010, lo: 0x9e, hi: 0x9e},
+	{value: 0x0054, lo: 0x9f, hi: 0x9f},
+	{value: 0x0012, lo: 0xa0, hi: 0xa0},
+	{value: 0x6552, lo: 0xa1, hi: 0xaf},
+	{value: 0x3012, lo: 0xb0, hi: 0xbf},
+	// Block 0xd, offset 0x57
+	{value: 0x0034, lo: 0x81, hi: 0x82},
+	{value: 0x0024, lo: 0x84, hi: 0x84},
+	{value: 0x0034, lo: 0x85, hi: 0x85},
+	{value: 0x0034, lo: 0x87, hi: 0x87},
+	{value: 0x0010, lo: 0x90, hi: 0xaa},
+	{value: 0x0010, lo: 0xaf, hi: 0xb3},
+	{value: 0x0054, lo: 0xb4, hi: 0xb4},
+	// Block 0xe, offset 0x5e
+	{value: 0x0014, lo: 0x80, hi: 0x85},
+	{value: 0x0024, lo: 0x90, hi: 0x97},
+	{value: 0x0034, lo: 0x98, hi: 0x9a},
+	{value: 0x0014, lo: 0x9c, hi: 0x9c},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0xf, offset 0x63
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x8a},
+	{value: 0x0034, lo: 0x8b, hi: 0x92},
+	{value: 0x0024, lo: 0x93, hi: 0x94},
+	{value: 0x0034, lo: 0x95, hi: 0x96},
+	{value: 0x0024, lo: 0x97, hi: 0x9b},
+	{value: 0x0034, lo: 0x9c, hi: 0x9c},
+	{value: 0x0024, lo: 0x9d, hi: 0x9e},
+	{value: 0x0034, lo: 0x9f, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	{value: 0x0010, lo: 0xab, hi: 0xab},
+	{value: 0x0010, lo: 0xae, hi: 0xaf},
+	{value: 0x0034, lo: 0xb0, hi: 0xb0},
+	{value: 0x0010, lo: 0xb1, hi: 0xbf},
+	// Block 0x10, offset 0x71
+	{value: 0x0010, lo: 0x80, hi: 0xbf},
+	// Block 0x11, offset 0x72
+	{value: 0x0010, lo: 0x80, hi: 0x93},
+	{value: 0x0010, lo: 0x95, hi: 0x95},
+	{value: 0x0024, lo: 0x96, hi: 0x9c},
+	{value: 0x0014, lo: 0x9d, hi: 0x9d},
+	{value: 0x0024, lo: 0x9f, hi: 0xa2},
+	{value: 0x0034, lo: 0xa3, hi: 0xa3},
+	{value: 0x0024, lo: 0xa4, hi: 0xa4},
+	{value: 0x0014, lo: 0xa5, hi: 0xa6},
+	{value: 0x0024, lo: 0xa7, hi: 0xa8},
+	{value: 0x0034, lo: 0xaa, hi: 0xaa},
+	{value: 0x0024, lo: 0xab, hi: 0xac},
+	{value: 0x0034, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xbc},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0x12, offset 0x80
+	{value: 0x0014, lo: 0x8f, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0x90},
+	{value: 0x0034, lo: 0x91, hi: 0x91},
+	{value: 0x0010, lo: 0x92, hi: 0xaf},
+	{value: 0x0024, lo: 0xb0, hi: 0xb0},
+	{value: 0x0034, lo: 0xb1, hi: 0xb1},
+	{value: 0x0024, lo: 0xb2, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	{value: 0x0024, lo: 0xb5, hi: 0xb6},
+	{value: 0x0034, lo: 0xb7, hi: 0xb9},
+	{value: 0x0024, lo: 0xba, hi: 0xba},
+	{value: 0x0034, lo: 0xbb, hi: 0xbc},
+	{value: 0x0024, lo: 0xbd, hi: 0xbd},
+	{value: 0x0034, lo: 0xbe, hi: 0xbe},
+	{value: 0x0024, lo: 0xbf, hi: 0xbf},
+	// Block 0x13, offset 0x8f
+	{value: 0x0024, lo: 0x80, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x82},
+	{value: 0x0024, lo: 0x83, hi: 0x83},
+	{value: 0x0034, lo: 0x84, hi: 0x84},
+	{value: 0x0024, lo: 0x85, hi: 0x85},
+	{value: 0x0034, lo: 0x86, hi: 0x86},
+	{value: 0x0024, lo: 0x87, hi: 0x87},
+	{value: 0x0034, lo: 0x88, hi: 0x88},
+	{value: 0x0024, lo: 0x89, hi: 0x8a},
+	{value: 0x0010, lo: 0x8d, hi: 0xbf},
+	// Block 0x14, offset 0x99
+	{value: 0x0010, lo: 0x80, hi: 0xa5},
+	{value: 0x0014, lo: 0xa6, hi: 0xb0},
+	{value: 0x0010, lo: 0xb1, hi: 0xb1},
+	// Block 0x15, offset 0x9c
+	{value: 0x0010, lo: 0x80, hi: 0xaa},
+	{value: 0x0024, lo: 0xab, hi: 0xb1},
+	{value: 0x0034, lo: 0xb2, hi: 0xb2},
+	{value: 0x0024, lo: 0xb3, hi: 0xb3},
+	{value: 0x0014, lo: 0xb4, hi: 0xb5},
+	{value: 0x0014, lo: 0xba, hi: 0xba},
+	{value: 0x0034, lo: 0xbd, hi: 0xbd},
+	// Block 0x16, offset 0xa3
+	{value: 0x0010, lo: 0x80, hi: 0x95},
+	{value: 0x0024, lo: 0x96, hi: 0x99},
+	{value: 0x0014, lo: 0x9a, hi: 0x9a},
+	{value: 0x0024, lo: 0x9b, hi: 0xa3},
+	{value: 0x0014, lo: 0xa4, hi: 0xa4},
+	{value: 0x0024, lo: 0xa5, hi: 0xa7},
+	{value: 0x0014, lo: 0xa8, hi: 0xa8},
+	{value: 0x0024, lo: 0xa9, hi: 0xad},
+	// Block 0x17, offset 0xab
+	{value: 0x0010, lo: 0x80, hi: 0x98},
+	{value: 0x0034, lo: 0x99, hi: 0x9b},
+	{value: 0x0010, lo: 0xa0, hi: 0xaa},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0x18, offset 0xaf
+	{value: 0x0010, lo: 0x80, hi: 0x87},
+	{value: 0x0004, lo: 0x88, hi: 0x88},
+	{value: 0x0010, lo: 0x89, hi: 0x8f},
+	{value: 0x0014, lo: 0x90, hi: 0x91},
+	{value: 0x0024, lo: 0x97, hi: 0x98},
+	{value: 0x0034, lo: 0x99, hi: 0x9b},
+	{value: 0x0024, lo: 0x9c, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x19, offset 0xb7
+	{value: 0x0014, lo: 0x80, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0xb9},
+	{value: 0x0014, lo: 0xba, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbb},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x1a, offset 0xbd
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x88},
+	{value: 0x0010, lo: 0x89, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x8e, hi: 0x90},
+	{value: 0x0024, lo: 0x91, hi: 0x91},
+	{value: 0x0034, lo: 0x92, hi: 0x92},
+	{value: 0x0024, lo: 0x93, hi: 0x94},
+	{value: 0x0014, lo: 0x95, hi: 0x97},
+	{value: 0x0010, lo: 0x98, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0014, lo: 0xb1, hi: 0xb1},
+	{value: 0x0010, lo: 0xb2, hi: 0xbf},
+	// Block 0x1b, offset 0xcb
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x8f, hi: 0x90},
+	{value: 0x0010, lo: 0x93, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb2},
+	{value: 0x0010, lo: 0xb6, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x1c, offset 0xd6
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x84},
+	{value: 0x0010, lo: 0x87, hi: 0x88},
+	{value: 0x0010, lo: 0x8b, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x8e, hi: 0x8e},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0010, lo: 0x9c, hi: 0x9d},
+	{value: 0x0010, lo: 0x9f, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xb1},
+	{value: 0x0010, lo: 0xbc, hi: 0xbc},
+	{value: 0x0024, lo: 0xbe, hi: 0xbe},
+	// Block 0x1d, offset 0xe3
+	{value: 0x0014, lo: 0x81, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8a},
+	{value: 0x0010, lo: 0x8f, hi: 0x90},
+	{value: 0x0010, lo: 0x93, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	{value: 0x0010, lo: 0xb5, hi: 0xb6},
+	{value: 0x0010, lo: 0xb8, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0x1e, offset 0xee
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x82},
+	{value: 0x0014, lo: 0x87, hi: 0x88},
+	{value: 0x0014, lo: 0x8b, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0014, lo: 0x91, hi: 0x91},
+	{value: 0x0010, lo: 0x99, hi: 0x9c},
+	{value: 0x0010, lo: 0x9e, hi: 0x9e},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0014, lo: 0xb0, hi: 0xb1},
+	{value: 0x0010, lo: 0xb2, hi: 0xb4},
+	{value: 0x0014, lo: 0xb5, hi: 0xb5},
+	// Block 0x1f, offset 0xfa
+	{value: 0x0014, lo: 0x81, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8d},
+	{value: 0x0010, lo: 0x8f, hi: 0x91},
+	{value: 0x0010, lo: 0x93, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	{value: 0x0010, lo: 0xb5, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x20, offset 0x104
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x85},
+	{value: 0x0014, lo: 0x87, hi: 0x88},
+	{value: 0x0010, lo: 0x89, hi: 0x89},
+	{value: 0x0010, lo: 0x8b, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x90},
+	{value: 0x0010, lo: 0xa0, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0010, lo: 0xb9, hi: 0xb9},
+	{value: 0x0014, lo: 0xba, hi: 0xbf},
+	// Block 0x21, offset 0x110
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x8f, hi: 0x90},
+	{value: 0x0010, lo: 0x93, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	{value: 0x0010, lo: 0xb5, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbe},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x22, offset 0x11b
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x84},
+	{value: 0x0010, lo: 0x87, hi: 0x88},
+	{value: 0x0010, lo: 0x8b, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0014, lo: 0x95, hi: 0x96},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0010, lo: 0x9c, hi: 0x9d},
+	{value: 0x0010, lo: 0x9f, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0010, lo: 0xb1, hi: 0xb1},
+	// Block 0x23, offset 0x127
+	{value: 0x0014, lo: 0x82, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8a},
+	{value: 0x0010, lo: 0x8e, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0x95},
+	{value: 0x0010, lo: 0x99, hi: 0x9a},
+	{value: 0x0010, lo: 0x9c, hi: 0x9c},
+	{value: 0x0010, lo: 0x9e, hi: 0x9f},
+	{value: 0x0010, lo: 0xa3, hi: 0xa4},
+	{value: 0x0010, lo: 0xa8, hi: 0xaa},
+	{value: 0x0010, lo: 0xae, hi: 0xb9},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0x24, offset 0x133
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x82},
+	{value: 0x0010, lo: 0x86, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x90},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	// Block 0x25, offset 0x13b
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x83},
+	{value: 0x0014, lo: 0x84, hi: 0x84},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x8e, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbd},
+	{value: 0x0014, lo: 0xbe, hi: 0xbf},
+	// Block 0x26, offset 0x145
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x84},
+	{value: 0x0014, lo: 0x86, hi: 0x88},
+	{value: 0x0014, lo: 0x8a, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0034, lo: 0x95, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0x9a},
+	{value: 0x0010, lo: 0x9c, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	// Block 0x27, offset 0x150
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x8e, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb3},
+	{value: 0x0010, lo: 0xb5, hi: 0xb9},
+	{value: 0x0034, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbe},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x28, offset 0x15b
+	{value: 0x0010, lo: 0x80, hi: 0x84},
+	{value: 0x0014, lo: 0x86, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x95, hi: 0x96},
+	{value: 0x0010, lo: 0x9c, hi: 0x9e},
+	{value: 0x0010, lo: 0xa0, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0010, lo: 0xb1, hi: 0xb3},
+	// Block 0x29, offset 0x167
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x8c},
+	{value: 0x0010, lo: 0x8e, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0xba},
+	{value: 0x0034, lo: 0xbb, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x2a, offset 0x16d
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x84},
+	{value: 0x0010, lo: 0x86, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x8e, hi: 0x8e},
+	{value: 0x0010, lo: 0x94, hi: 0x97},
+	{value: 0x0010, lo: 0x9f, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa3},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0010, lo: 0xba, hi: 0xbf},
+	// Block 0x2b, offset 0x178
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x96},
+	{value: 0x0010, lo: 0x9a, hi: 0xb1},
+	{value: 0x0010, lo: 0xb3, hi: 0xbb},
+	{value: 0x0010, lo: 0xbd, hi: 0xbd},
+	// Block 0x2c, offset 0x17e
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0034, lo: 0x8a, hi: 0x8a},
+	{value: 0x0010, lo: 0x8f, hi: 0x91},
+	{value: 0x0014, lo: 0x92, hi: 0x94},
+	{value: 0x0014, lo: 0x96, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0x9f},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	// Block 0x2d, offset 0x186
+	{value: 0x0014, lo: 0xb1, hi: 0xb1},
+	{value: 0x0014, lo: 0xb4, hi: 0xb7},
+	{value: 0x0034, lo: 0xb8, hi: 0xba},
+	// Block 0x2e, offset 0x189
+	{value: 0x0004, lo: 0x86, hi: 0x86},
+	{value: 0x0014, lo: 0x87, hi: 0x87},
+	{value: 0x0034, lo: 0x88, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8e},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0x2f, offset 0x18e
+	{value: 0x0014, lo: 0xb1, hi: 0xb1},
+	{value: 0x0014, lo: 0xb4, hi: 0xb7},
+	{value: 0x0034, lo: 0xb8, hi: 0xba},
+	{value: 0x0014, lo: 0xbb, hi: 0xbc},
+	// Block 0x30, offset 0x192
+	{value: 0x0004, lo: 0x86, hi: 0x86},
+	{value: 0x0034, lo: 0x88, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8e},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0x31, offset 0x196
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0034, lo: 0x98, hi: 0x99},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	{value: 0x0034, lo: 0xb5, hi: 0xb5},
+	{value: 0x0034, lo: 0xb7, hi: 0xb7},
+	{value: 0x0034, lo: 0xb9, hi: 0xb9},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0x32, offset 0x19d
+	{value: 0x0010, lo: 0x80, hi: 0x87},
+	{value: 0x0010, lo: 0x89, hi: 0xac},
+	{value: 0x0034, lo: 0xb1, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	{value: 0x0014, lo: 0xb5, hi: 0xb9},
+	{value: 0x0034, lo: 0xba, hi: 0xbd},
+	{value: 0x0014, lo: 0xbe, hi: 0xbe},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0x33, offset 0x1a6
+	{value: 0x0034, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0024, lo: 0x82, hi: 0x83},
+	{value: 0x0034, lo: 0x84, hi: 0x84},
+	{value: 0x0024, lo: 0x86, hi: 0x87},
+	{value: 0x0010, lo: 0x88, hi: 0x8c},
+	{value: 0x0014, lo: 0x8d, hi: 0x97},
+	{value: 0x0014, lo: 0x99, hi: 0xbc},
+	// Block 0x34, offset 0x1ae
+	{value: 0x0034, lo: 0x86, hi: 0x86},
+	// Block 0x35, offset 0x1af
+	{value: 0x0010, lo: 0xab, hi: 0xac},
+	{value: 0x0014, lo: 0xad, hi: 0xb0},
+	{value: 0x0010, lo: 0xb1, hi: 0xb1},
+	{value: 0x0014, lo: 0xb2, hi: 0xb6},
+	{value: 0x0034, lo: 0xb7, hi: 0xb7},
+	{value: 0x0010, lo: 0xb8, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbc},
+	{value: 0x0014, lo: 0xbd, hi: 0xbe},
+	// Block 0x36, offset 0x1b8
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x96, hi: 0x97},
+	{value: 0x0014, lo: 0x98, hi: 0x99},
+	{value: 0x0014, lo: 0x9e, hi: 0xa0},
+	{value: 0x0010, lo: 0xa2, hi: 0xa4},
+	{value: 0x0010, lo: 0xa7, hi: 0xad},
+	{value: 0x0014, lo: 0xb1, hi: 0xb4},
+	// Block 0x37, offset 0x1bf
+	{value: 0x0014, lo: 0x82, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x84},
+	{value: 0x0014, lo: 0x85, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x8f, hi: 0x9c},
+	{value: 0x0014, lo: 0x9d, hi: 0x9d},
+	{value: 0x6c53, lo: 0xa0, hi: 0xbf},
+	// Block 0x38, offset 0x1c7
+	{value: 0x0010, lo: 0x80, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0x98},
+	{value: 0x0010, lo: 0x9a, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x39, offset 0x1cd
+	{value: 0x0010, lo: 0x80, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb5},
+	{value: 0x0010, lo: 0xb8, hi: 0xbe},
+	// Block 0x3a, offset 0x1d2
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x82, hi: 0x85},
+	{value: 0x0010, lo: 0x88, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0xbf},
+	// Block 0x3b, offset 0x1d6
+	{value: 0x0010, lo: 0x80, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0x95},
+	{value: 0x0010, lo: 0x98, hi: 0xbf},
+	// Block 0x3c, offset 0x1d9
+	{value: 0x0010, lo: 0x80, hi: 0x9a},
+	{value: 0x0024, lo: 0x9d, hi: 0x9f},
+	// Block 0x3d, offset 0x1db
+	{value: 0x0010, lo: 0x80, hi: 0x8f},
+	{value: 0x7453, lo: 0xa0, hi: 0xaf},
+	{value: 0x7853, lo: 0xb0, hi: 0xbf},
+	// Block 0x3e, offset 0x1de
+	{value: 0x7c53, lo: 0x80, hi: 0x8f},
+	{value: 0x8053, lo: 0x90, hi: 0x9f},
+	{value: 0x7c53, lo: 0xa0, hi: 0xaf},
+	{value: 0x0813, lo: 0xb0, hi: 0xb5},
+	{value: 0x0892, lo: 0xb8, hi: 0xbd},
+	// Block 0x3f, offset 0x1e3
+	{value: 0x0010, lo: 0x81, hi: 0xbf},
+	// Block 0x40, offset 0x1e4
+	{value: 0x0010, lo: 0x80, hi: 0xac},
+	{value: 0x0010, lo: 0xaf, hi: 0xbf},
+	// Block 0x41, offset 0x1e6
+	{value: 0x0010, lo: 0x81, hi: 0x9a},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x42, offset 0x1e8
+	{value: 0x0010, lo: 0x80, hi: 0xaa},
+	{value: 0x0010, lo: 0xae, hi: 0xb8},
+	// Block 0x43, offset 0x1ea
+	{value: 0x0010, lo: 0x80, hi: 0x91},
+	{value: 0x0014, lo: 0x92, hi: 0x93},
+	{value: 0x0034, lo: 0x94, hi: 0x94},
+	{value: 0x0030, lo: 0x95, hi: 0x95},
+	{value: 0x0010, lo: 0x9f, hi: 0xb1},
+	{value: 0x0014, lo: 0xb2, hi: 0xb3},
+	{value: 0x0030, lo: 0xb4, hi: 0xb4},
+	// Block 0x44, offset 0x1f1
+	{value: 0x0010, lo: 0x80, hi: 0x91},
+	{value: 0x0014, lo: 0x92, hi: 0x93},
+	{value: 0x0010, lo: 0xa0, hi: 0xac},
+	{value: 0x0010, lo: 0xae, hi: 0xb0},
+	{value: 0x0014, lo: 0xb2, hi: 0xb3},
+	// Block 0x45, offset 0x1f6
+	{value: 0x0014, lo: 0xb4, hi: 0xb5},
+	{value: 0x0010, lo: 0xb6, hi: 0xb6},
+	{value: 0x0014, lo: 0xb7, hi: 0xbd},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0x46, offset 0x1fa
+	{value: 0x0010, lo: 0x80, hi: 0x85},
+	{value: 0x0014, lo: 0x86, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0x88},
+	{value: 0x0014, lo: 0x89, hi: 0x91},
+	{value: 0x0034, lo: 0x92, hi: 0x92},
+	{value: 0x0014, lo: 0x93, hi: 0x93},
+	{value: 0x0004, lo: 0x97, hi: 0x97},
+	{value: 0x0024, lo: 0x9d, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	// Block 0x47, offset 0x203
+	{value: 0x0014, lo: 0x8b, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x48, offset 0x206
+	{value: 0x0010, lo: 0x80, hi: 0x82},
+	{value: 0x0014, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x84, hi: 0xb8},
+	// Block 0x49, offset 0x209
+	{value: 0x0010, lo: 0x80, hi: 0x84},
+	{value: 0x0014, lo: 0x85, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0xa8},
+	{value: 0x0034, lo: 0xa9, hi: 0xa9},
+	{value: 0x0010, lo: 0xaa, hi: 0xaa},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0x4a, offset 0x20f
+	{value: 0x0010, lo: 0x80, hi: 0xb5},
+	// Block 0x4b, offset 0x210
+	{value: 0x0010, lo: 0x80, hi: 0x9e},
+	{value: 0x0014, lo: 0xa0, hi: 0xa2},
+	{value: 0x0010, lo: 0xa3, hi: 0xa6},
+	{value: 0x0014, lo: 0xa7, hi: 0xa8},
+	{value: 0x0010, lo: 0xa9, hi: 0xab},
+	{value: 0x0010, lo: 0xb0, hi: 0xb1},
+	{value: 0x0014, lo: 0xb2, hi: 0xb2},
+	{value: 0x0010, lo: 0xb3, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xb9},
+	{value: 0x0024, lo: 0xba, hi: 0xba},
+	{value: 0x0034, lo: 0xbb, hi: 0xbb},
+	// Block 0x4c, offset 0x21b
+	{value: 0x0010, lo: 0x86, hi: 0x8f},
+	// Block 0x4d, offset 0x21c
+	{value: 0x0010, lo: 0x90, hi: 0x9a},
+	// Block 0x4e, offset 0x21d
+	{value: 0x0010, lo: 0x80, hi: 0x96},
+	{value: 0x0024, lo: 0x97, hi: 0x97},
+	{value: 0x0034, lo: 0x98, hi: 0x98},
+	{value: 0x0010, lo: 0x99, hi: 0x9a},
+	{value: 0x0014, lo: 0x9b, hi: 0x9b},
+	// Block 0x4f, offset 0x222
+	{value: 0x0010, lo: 0x95, hi: 0x95},
+	{value: 0x0014, lo: 0x96, hi: 0x96},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0014, lo: 0x98, hi: 0x9e},
+	{value: 0x0034, lo: 0xa0, hi: 0xa0},
+	{value: 0x0010, lo: 0xa1, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa2},
+	{value: 0x0010, lo: 0xa3, hi: 0xa4},
+	{value: 0x0014, lo: 0xa5, hi: 0xac},
+	{value: 0x0010, lo: 0xad, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb4},
+	{value: 0x0024, lo: 0xb5, hi: 0xbc},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0x50, offset 0x22f
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0004, lo: 0xa7, hi: 0xa7},
+	{value: 0x0024, lo: 0xb0, hi: 0xb4},
+	{value: 0x0034, lo: 0xb5, hi: 0xba},
+	{value: 0x0024, lo: 0xbb, hi: 0xbc},
+	{value: 0x0034, lo: 0xbd, hi: 0xbd},
+	{value: 0x0014, lo: 0xbe, hi: 0xbe},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0x51, offset 0x238
+	{value: 0x0034, lo: 0x80, hi: 0x80},
+	{value: 0x0024, lo: 0x81, hi: 0x82},
+	{value: 0x0034, lo: 0x83, hi: 0x84},
+	{value: 0x0024, lo: 0x85, hi: 0x89},
+	{value: 0x0034, lo: 0x8a, hi: 0x8a},
+	{value: 0x0024, lo: 0x8b, hi: 0x9c},
+	{value: 0x0034, lo: 0x9d, hi: 0x9d},
+	{value: 0x0024, lo: 0xa0, hi: 0xa5},
+	{value: 0x0034, lo: 0xa6, hi: 0xa6},
+	{value: 0x0024, lo: 0xa7, hi: 0xaa},
+	{value: 0x0034, lo: 0xab, hi: 0xab},
+	// Block 0x52, offset 0x243
+	{value: 0x0014, lo: 0x80, hi: 0x83},
+	{value: 0x0010, lo: 0x84, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	{value: 0x0010, lo: 0xb5, hi: 0xb5},
+	{value: 0x0014, lo: 0xb6, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbb},
+	{value: 0x0014, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x53, offset 0x24b
+	{value: 0x0010, lo: 0x80, hi: 0x81},
+	{value: 0x0014, lo: 0x82, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x83},
+	{value: 0x0030, lo: 0x84, hi: 0x84},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0024, lo: 0xab, hi: 0xab},
+	{value: 0x0034, lo: 0xac, hi: 0xac},
+	{value: 0x0024, lo: 0xad, hi: 0xb3},
+	// Block 0x54, offset 0x254
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa5},
+	{value: 0x0010, lo: 0xa6, hi: 0xa7},
+	{value: 0x0014, lo: 0xa8, hi: 0xa9},
+	{value: 0x0030, lo: 0xaa, hi: 0xaa},
+	{value: 0x0034, lo: 0xab, hi: 0xab},
+	{value: 0x0014, lo: 0xac, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xbf},
+	// Block 0x55, offset 0x25d
+	{value: 0x0010, lo: 0x80, hi: 0xa5},
+	{value: 0x0034, lo: 0xa6, hi: 0xa6},
+	{value: 0x0010, lo: 0xa7, hi: 0xa7},
+	{value: 0x0014, lo: 0xa8, hi: 0xa9},
+	{value: 0x0010, lo: 0xaa, hi: 0xac},
+	{value: 0x0014, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xae},
+	{value: 0x0014, lo: 0xaf, hi: 0xb1},
+	{value: 0x0030, lo: 0xb2, hi: 0xb3},
+	// Block 0x56, offset 0x266
+	{value: 0x0010, lo: 0x80, hi: 0xab},
+	{value: 0x0014, lo: 0xac, hi: 0xb3},
+	{value: 0x0010, lo: 0xb4, hi: 0xb5},
+	{value: 0x0014, lo: 0xb6, hi: 0xb6},
+	{value: 0x0034, lo: 0xb7, hi: 0xb7},
+	// Block 0x57, offset 0x26b
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x8d, hi: 0xb7},
+	{value: 0x0014, lo: 0xb8, hi: 0xbd},
+	// Block 0x58, offset 0x26e
+	{value: 0x32ea, lo: 0x80, hi: 0x80},
+	{value: 0x336a, lo: 0x81, hi: 0x81},
+	{value: 0x33ea, lo: 0x82, hi: 0x82},
+	{value: 0x346a, lo: 0x83, hi: 0x83},
+	{value: 0x34ea, lo: 0x84, hi: 0x84},
+	{value: 0x356a, lo: 0x85, hi: 0x85},
+	{value: 0x35ea, lo: 0x86, hi: 0x86},
+	{value: 0x366a, lo: 0x87, hi: 0x87},
+	{value: 0x36ea, lo: 0x88, hi: 0x88},
+	{value: 0x0316, lo: 0x89, hi: 0x8a},
+	{value: 0x8353, lo: 0x90, hi: 0xba},
+	{value: 0x8353, lo: 0xbd, hi: 0xbf},
+	// Block 0x59, offset 0x27a
+	{value: 0x0024, lo: 0x90, hi: 0x92},
+	{value: 0x0034, lo: 0x94, hi: 0x99},
+	{value: 0x0024, lo: 0x9a, hi: 0x9b},
+	{value: 0x0034, lo: 0x9c, hi: 0x9f},
+	{value: 0x0024, lo: 0xa0, hi: 0xa0},
+	{value: 0x0010, lo: 0xa1, hi: 0xa1},
+	{value: 0x0034, lo: 0xa2, hi: 0xa8},
+	{value: 0x0010, lo: 0xa9, hi: 0xac},
+	{value: 0x0034, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xb3},
+	{value: 0x0024, lo: 0xb4, hi: 0xb4},
+	{value: 0x0010, lo: 0xb5, hi: 0xb7},
+	{value: 0x0024, lo: 0xb8, hi: 0xb9},
+	{value: 0x0010, lo: 0xba, hi: 0xba},
+	// Block 0x5a, offset 0x288
+	{value: 0x0012, lo: 0x80, hi: 0xab},
+	{value: 0x0015, lo: 0xac, hi: 0xbf},
+	// Block 0x5b, offset 0x28a
+	{value: 0x0015, lo: 0x80, hi: 0xaa},
+	{value: 0x0012, lo: 0xab, hi: 0xb7},
+	{value: 0x0015, lo: 0xb8, hi: 0xb8},
+	{value: 0x8752, lo: 0xb9, hi: 0xb9},
+	{value: 0x0012, lo: 0xba, hi: 0xbc},
+	{value: 0x8b52, lo: 0xbd, hi: 0xbd},
+	{value: 0x0012, lo: 0xbe, hi: 0xbf},
+	// Block 0x5c, offset 0x291
+	{value: 0x0012, lo: 0x80, hi: 0x8d},
+	{value: 0x8f52, lo: 0x8e, hi: 0x8e},
+	{value: 0x0012, lo: 0x8f, hi: 0x9a},
+	{value: 0x0015, lo: 0x9b, hi: 0xbf},
+	// Block 0x5d, offset 0x295
+	{value: 0x0024, lo: 0x80, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x82},
+	{value: 0x0024, lo: 0x83, hi: 0x89},
+	{value: 0x0034, lo: 0x8a, hi: 0x8a},
+	{value: 0x0024, lo: 0x8b, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x90},
+	{value: 0x0024, lo: 0x91, hi: 0xb5},
+	{value: 0x0034, lo: 0xb6, hi: 0xba},
+	{value: 0x0024, lo: 0xbb, hi: 0xbb},
+	{value: 0x0034, lo: 0xbc, hi: 0xbd},
+	{value: 0x0024, lo: 0xbe, hi: 0xbe},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0x5e, offset 0x2a1
+	{value: 0x0117, lo: 0x80, hi: 0xbf},
+	// Block 0x5f, offset 0x2a2
+	{value: 0x0117, lo: 0x80, hi: 0x95},
+	{value: 0x379a, lo: 0x96, hi: 0x96},
+	{value: 0x384a, lo: 0x97, hi: 0x97},
+	{value: 0x38fa, lo: 0x98, hi: 0x98},
+	{value: 0x39aa, lo: 0x99, hi: 0x99},
+	{value: 0x3a5a, lo: 0x9a, hi: 0x9a},
+	{value: 0x3b0a, lo: 0x9b, hi: 0x9b},
+	{value: 0x0012, lo: 0x9c, hi: 0x9d},
+	{value: 0x3bbb, lo: 0x9e, hi: 0x9e},
+	{value: 0x0012, lo: 0x9f, hi: 0x9f},
+	{value: 0x0117, lo: 0xa0, hi: 0xbf},
+	// Block 0x60, offset 0x2ad
+	{value: 0x0812, lo: 0x80, hi: 0x87},
+	{value: 0x0813, lo: 0x88, hi: 0x8f},
+	{value: 0x0812, lo: 0x90, hi: 0x95},
+	{value: 0x0813, lo: 0x98, hi: 0x9d},
+	{value: 0x0812, lo: 0xa0, hi: 0xa7},
+	{value: 0x0813, lo: 0xa8, hi: 0xaf},
+	{value: 0x0812, lo: 0xb0, hi: 0xb7},
+	{value: 0x0813, lo: 0xb8, hi: 0xbf},
+	// Block 0x61, offset 0x2b5
+	{value: 0x0004, lo: 0x8b, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8f},
+	{value: 0x0054, lo: 0x98, hi: 0x99},
+	{value: 0x0054, lo: 0xa4, hi: 0xa4},
+	{value: 0x0054, lo: 0xa7, hi: 0xa7},
+	{value: 0x0014, lo: 0xaa, hi: 0xae},
+	{value: 0x0010, lo: 0xaf, hi: 0xaf},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0x62, offset 0x2bd
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x94, hi: 0x94},
+	{value: 0x0014, lo: 0xa0, hi: 0xa4},
+	{value: 0x0014, lo: 0xa6, hi: 0xaf},
+	{value: 0x0015, lo: 0xb1, hi: 0xb1},
+	{value: 0x0015, lo: 0xbf, hi: 0xbf},
+	// Block 0x63, offset 0x2c3
+	{value: 0x0015, lo: 0x90, hi: 0x9c},
+	// Block 0x64, offset 0x2c4
+	{value: 0x0024, lo: 0x90, hi: 0x91},
+	{value: 0x0034, lo: 0x92, hi: 0x93},
+	{value: 0x0024, lo: 0x94, hi: 0x97},
+	{value: 0x0034, lo: 0x98, hi: 0x9a},
+	{value: 0x0024, lo: 0x9b, hi: 0x9c},
+	{value: 0x0014, lo: 0x9d, hi: 0xa0},
+	{value: 0x0024, lo: 0xa1, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa4},
+	{value: 0x0034, lo: 0xa5, hi: 0xa6},
+	{value: 0x0024, lo: 0xa7, hi: 0xa7},
+	{value: 0x0034, lo: 0xa8, hi: 0xa8},
+	{value: 0x0024, lo: 0xa9, hi: 0xa9},
+	{value: 0x0034, lo: 0xaa, hi: 0xaf},
+	{value: 0x0024, lo: 0xb0, hi: 0xb0},
+	// Block 0x65, offset 0x2d2
+	{value: 0x0016, lo: 0x85, hi: 0x86},
+	{value: 0x0012, lo: 0x87, hi: 0x89},
+	{value: 0xa452, lo: 0x8e, hi: 0x8e},
+	{value: 0x1013, lo: 0xa0, hi: 0xaf},
+	{value: 0x1012, lo: 0xb0, hi: 0xbf},
+	// Block 0x66, offset 0x2d7
+	{value: 0x0010, lo: 0x80, hi: 0x82},
+	{value: 0x0716, lo: 0x83, hi: 0x84},
+	{value: 0x0010, lo: 0x85, hi: 0x88},
+	// Block 0x67, offset 0x2da
+	{value: 0xa753, lo: 0xb6, hi: 0xb7},
+	{value: 0xaa53, lo: 0xb8, hi: 0xb9},
+	{value: 0xad53, lo: 0xba, hi: 0xbb},
+	{value: 0xaa53, lo: 0xbc, hi: 0xbd},
+	{value: 0xa753, lo: 0xbe, hi: 0xbf},
+	// Block 0x68, offset 0x2df
+	{value: 0x3013, lo: 0x80, hi: 0x8f},
+	{value: 0x6553, lo: 0x90, hi: 0x9f},
+	{value: 0xb053, lo: 0xa0, hi: 0xaf},
+	{value: 0x3012, lo: 0xb0, hi: 0xbf},
+	// Block 0x69, offset 0x2e3
+	{value: 0x0117, lo: 0x80, hi: 0xa3},
+	{value: 0x0012, lo: 0xa4, hi: 0xa4},
+	{value: 0x0716, lo: 0xab, hi: 0xac},
+	{value: 0x0316, lo: 0xad, hi: 0xae},
+	{value: 0x0024, lo: 0xaf, hi: 0xb1},
+	{value: 0x0117, lo: 0xb2, hi: 0xb3},
+	// Block 0x6a, offset 0x2e9
+	{value: 0x6c52, lo: 0x80, hi: 0x9f},
+	{value: 0x7052, lo: 0xa0, hi: 0xa5},
+	{value: 0x7052, lo: 0xa7, hi: 0xa7},
+	{value: 0x7052, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0x6b, offset 0x2ee
+	{value: 0x0010, lo: 0x80, hi: 0xa7},
+	{value: 0x0014, lo: 0xaf, hi: 0xaf},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0x6c, offset 0x2f1
+	{value: 0x0010, lo: 0x80, hi: 0x96},
+	{value: 0x0010, lo: 0xa0, hi: 0xa6},
+	{value: 0x0010, lo: 0xa8, hi: 0xae},
+	{value: 0x0010, lo: 0xb0, hi: 0xb6},
+	{value: 0x0010, lo: 0xb8, hi: 0xbe},
+	// Block 0x6d, offset 0x2f6
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0010, lo: 0x88, hi: 0x8e},
+	{value: 0x0010, lo: 0x90, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0x9e},
+	{value: 0x0024, lo: 0xa0, hi: 0xbf},
+	// Block 0x6e, offset 0x2fb
+	{value: 0x0014, lo: 0xaf, hi: 0xaf},
+	// Block 0x6f, offset 0x2fc
+	{value: 0x0014, lo: 0x85, hi: 0x85},
+	{value: 0x0034, lo: 0xaa, hi: 0xad},
+	{value: 0x0030, lo: 0xae, hi: 0xaf},
+	{value: 0x0004, lo: 0xb1, hi: 0xb5},
+	{value: 0x0014, lo: 0xbb, hi: 0xbb},
+	{value: 0x0010, lo: 0xbc, hi: 0xbc},
+	// Block 0x70, offset 0x302
+	{value: 0x0034, lo: 0x99, hi: 0x9a},
+	{value: 0x0004, lo: 0x9b, hi: 0x9e},
+	// Block 0x71, offset 0x304
+	{value: 0x0004, lo: 0xbc, hi: 0xbe},
+	// Block 0x72, offset 0x305
+	{value: 0x0010, lo: 0x85, hi: 0xaf},
+	{value: 0x0010, lo: 0xb1, hi: 0xbf},
+	// Block 0x73, offset 0x307
+	{value: 0x0010, lo: 0x80, hi: 0x8e},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x74, offset 0x309
+	{value: 0x0010, lo: 0x80, hi: 0x94},
+	{value: 0x0014, lo: 0x95, hi: 0x95},
+	{value: 0x0010, lo: 0x96, hi: 0xbf},
+	// Block 0x75, offset 0x30c
+	{value: 0x0010, lo: 0x80, hi: 0x8c},
+	// Block 0x76, offset 0x30d
+	{value: 0x0010, lo: 0x90, hi: 0xb7},
+	{value: 0x0014, lo: 0xb8, hi: 0xbd},
+	// Block 0x77, offset 0x30f
+	{value: 0x0010, lo: 0x80, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8c},
+	{value: 0x0010, lo: 0x90, hi: 0xab},
+	// Block 0x78, offset 0x312
+	{value: 0x0117, lo: 0x80, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xae},
+	{value: 0x0024, lo: 0xaf, hi: 0xaf},
+	{value: 0x0014, lo: 0xb0, hi: 0xb2},
+	{value: 0x0024, lo: 0xb4, hi: 0xbd},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x79, offset 0x318
+	{value: 0x0117, lo: 0x80, hi: 0x9b},
+	{value: 0x0015, lo: 0x9c, hi: 0x9d},
+	{value: 0x0024, lo: 0x9e, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x7a, offset 0x31c
+	{value: 0x0010, lo: 0x80, hi: 0xaf},
+	{value: 0x0024, lo: 0xb0, hi: 0xb1},
+	// Block 0x7b, offset 0x31e
+	{value: 0x0004, lo: 0x80, hi: 0x87},
+	{value: 0x0014, lo: 0x88, hi: 0xa1},
+	{value: 0x0117, lo: 0xa2, hi: 0xaf},
+	{value: 0x0012, lo: 0xb0, hi: 0xb1},
+	{value: 0x0117, lo: 0xb2, hi: 0xbf},
+	// Block 0x7c, offset 0x323
+	{value: 0x0117, lo: 0x80, hi: 0xaf},
+	{value: 0x0015, lo: 0xb0, hi: 0xb0},
+	{value: 0x0012, lo: 0xb1, hi: 0xb8},
+	{value: 0x0316, lo: 0xb9, hi: 0xba},
+	{value: 0x0716, lo: 0xbb, hi: 0xbc},
+	{value: 0x8753, lo: 0xbd, hi: 0xbd},
+	{value: 0x0117, lo: 0xbe, hi: 0xbf},
+	// Block 0x7d, offset 0x32a
+	{value: 0x0117, lo: 0x80, hi: 0x83},
+	{value: 0x6553, lo: 0x84, hi: 0x84},
+	{value: 0x918b, lo: 0x85, hi: 0x85},
+	{value: 0x8f53, lo: 0x86, hi: 0x86},
+	{value: 0x0f16, lo: 0x87, hi: 0x88},
+	{value: 0x0316, lo: 0x89, hi: 0x8a},
+	{value: 0x91eb, lo: 0x8b, hi: 0x8b},
+	{value: 0x0117, lo: 0x8c, hi: 0x9b},
+	{value: 0x924b, lo: 0x9c, hi: 0x9c},
+	{value: 0x0015, lo: 0xb1, hi: 0xb4},
+	{value: 0x0316, lo: 0xb5, hi: 0xb6},
+	{value: 0x0010, lo: 0xb7, hi: 0xb7},
+	{value: 0x0015, lo: 0xb8, hi: 0xb9},
+	{value: 0x0012, lo: 0xba, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbf},
+	// Block 0x7e, offset 0x339
+	{value: 0x0010, lo: 0x80, hi: 0x81},
+	{value: 0x0014, lo: 0x82, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0x85},
+	{value: 0x0034, lo: 0x86, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0x8a},
+	{value: 0x0014, lo: 0x8b, hi: 0x8b},
+	{value: 0x0010, lo: 0x8c, hi: 0xa4},
+	{value: 0x0014, lo: 0xa5, hi: 0xa6},
+	{value: 0x0010, lo: 0xa7, hi: 0xa7},
+	{value: 0x0034, lo: 0xac, hi: 0xac},
+	// Block 0x7f, offset 0x343
+	{value: 0x0010, lo: 0x80, hi: 0xb3},
+	// Block 0x80, offset 0x344
+	{value: 0x0010, lo: 0x80, hi: 0x83},
+	{value: 0x0034, lo: 0x84, hi: 0x84},
+	{value: 0x0014, lo: 0x85, hi: 0x85},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0024, lo: 0xa0, hi: 0xb1},
+	{value: 0x0010, lo: 0xb2, hi: 0xb7},
+	{value: 0x0010, lo: 0xbb, hi: 0xbb},
+	{value: 0x0010, lo: 0xbd, hi: 0xbe},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x81, offset 0x34d
+	{value: 0x0010, lo: 0x80, hi: 0xa5},
+	{value: 0x0014, lo: 0xa6, hi: 0xaa},
+	{value: 0x0034, lo: 0xab, hi: 0xad},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0x82, offset 0x351
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0014, lo: 0x87, hi: 0x91},
+	{value: 0x0010, lo: 0x92, hi: 0x92},
+	{value: 0x0030, lo: 0x93, hi: 0x93},
+	{value: 0x0010, lo: 0xa0, hi: 0xbc},
+	// Block 0x83, offset 0x356
+	{value: 0x0014, lo: 0x80, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0xb2},
+	{value: 0x0034, lo: 0xb3, hi: 0xb3},
+	{value: 0x0010, lo: 0xb4, hi: 0xb5},
+	{value: 0x0014, lo: 0xb6, hi: 0xb9},
+	{value: 0x0010, lo: 0xba, hi: 0xbb},
+	{value: 0x0014, lo: 0xbc, hi: 0xbd},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0x84, offset 0x35e
+	{value: 0x0030, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x8f, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0014, lo: 0xa5, hi: 0xa5},
+	{value: 0x0004, lo: 0xa6, hi: 0xa6},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x85, offset 0x364
+	{value: 0x0010, lo: 0x80, hi: 0xa8},
+	{value: 0x0014, lo: 0xa9, hi: 0xae},
+	{value: 0x0010, lo: 0xaf, hi: 0xb0},
+	{value: 0x0014, lo: 0xb1, hi: 0xb2},
+	{value: 0x0010, lo: 0xb3, hi: 0xb4},
+	{value: 0x0014, lo: 0xb5, hi: 0xb6},
+	// Block 0x86, offset 0x36a
+	{value: 0x0010, lo: 0x80, hi: 0x82},
+	{value: 0x0014, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x84, hi: 0x8b},
+	{value: 0x0014, lo: 0x8c, hi: 0x8c},
+	{value: 0x0010, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0004, lo: 0xb0, hi: 0xb0},
+	{value: 0x0010, lo: 0xbb, hi: 0xbb},
+	{value: 0x0014, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbd},
+	// Block 0x87, offset 0x374
+	{value: 0x0024, lo: 0xb0, hi: 0xb0},
+	{value: 0x0024, lo: 0xb2, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	{value: 0x0024, lo: 0xb7, hi: 0xb8},
+	{value: 0x0024, lo: 0xbe, hi: 0xbf},
+	// Block 0x88, offset 0x379
+	{value: 0x0024, lo: 0x81, hi: 0x81},
+	{value: 0x0004, lo: 0x9d, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xab},
+	{value: 0x0014, lo: 0xac, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xaf},
+	{value: 0x0010, lo: 0xb2, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb4},
+	{value: 0x0010, lo: 0xb5, hi: 0xb5},
+	{value: 0x0034, lo: 0xb6, hi: 0xb6},
+	// Block 0x89, offset 0x382
+	{value: 0x0010, lo: 0x81, hi: 0x86},
+	{value: 0x0010, lo: 0x89, hi: 0x8e},
+	{value: 0x0010, lo: 0x91, hi: 0x96},
+	{value: 0x0010, lo: 0xa0, hi: 0xa6},
+	{value: 0x0010, lo: 0xa8, hi: 0xae},
+	{value: 0x0012, lo: 0xb0, hi: 0xbf},
+	// Block 0x8a, offset 0x388
+	{value: 0x0012, lo: 0x80, hi: 0x92},
+	{value: 0xb352, lo: 0x93, hi: 0x93},
+	{value: 0x0012, lo: 0x94, hi: 0x9a},
+	{value: 0x0014, lo: 0x9b, hi: 0x9b},
+	{value: 0x0015, lo: 0x9c, hi: 0x9f},
+	{value: 0x0012, lo: 0xa0, hi: 0xa8},
+	{value: 0x0015, lo: 0xa9, hi: 0xa9},
+	{value: 0x0004, lo: 0xaa, hi: 0xab},
+	{value: 0x74d2, lo: 0xb0, hi: 0xbf},
+	// Block 0x8b, offset 0x391
+	{value: 0x78d2, lo: 0x80, hi: 0x8f},
+	{value: 0x7cd2, lo: 0x90, hi: 0x9f},
+	{value: 0x80d2, lo: 0xa0, hi: 0xaf},
+	{value: 0x7cd2, lo: 0xb0, hi: 0xbf},
+	// Block 0x8c, offset 0x395
+	{value: 0x0010, lo: 0x80, hi: 0xa4},
+	{value: 0x0014, lo: 0xa5, hi: 0xa5},
+	{value: 0x0010, lo: 0xa6, hi: 0xa7},
+	{value: 0x0014, lo: 0xa8, hi: 0xa8},
+	{value: 0x0010, lo: 0xa9, hi: 0xaa},
+	{value: 0x0010, lo: 0xac, hi: 0xac},
+	{value: 0x0034, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x8d, offset 0x39d
+	{value: 0x0010, lo: 0x80, hi: 0xa3},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0x8e, offset 0x39f
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0010, lo: 0x8b, hi: 0xbb},
+	// Block 0x8f, offset 0x3a1
+	{value: 0x0010, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x83, hi: 0x84},
+	{value: 0x0010, lo: 0x86, hi: 0xbf},
+	// Block 0x90, offset 0x3a4
+	{value: 0x0010, lo: 0x80, hi: 0xb1},
+	{value: 0x0004, lo: 0xb2, hi: 0xbf},
+	// Block 0x91, offset 0x3a6
+	{value: 0x0004, lo: 0x80, hi: 0x82},
+	{value: 0x0010, lo: 0x93, hi: 0xbf},
+	// Block 0x92, offset 0x3a8
+	{value: 0x0010, lo: 0x80, hi: 0xbd},
+	// Block 0x93, offset 0x3a9
+	{value: 0x0010, lo: 0x90, hi: 0xbf},
+	// Block 0x94, offset 0x3aa
+	{value: 0x0010, lo: 0x80, hi: 0x8f},
+	{value: 0x0010, lo: 0x92, hi: 0xbf},
+	// Block 0x95, offset 0x3ac
+	{value: 0x0010, lo: 0x80, hi: 0x87},
+	{value: 0x0010, lo: 0xb0, hi: 0xbb},
+	// Block 0x96, offset 0x3ae
+	{value: 0x0014, lo: 0x80, hi: 0x8f},
+	{value: 0x0054, lo: 0x93, hi: 0x93},
+	{value: 0x0024, lo: 0xa0, hi: 0xa6},
+	{value: 0x0034, lo: 0xa7, hi: 0xad},
+	{value: 0x0024, lo: 0xae, hi: 0xaf},
+	{value: 0x0010, lo: 0xb3, hi: 0xb4},
+	// Block 0x97, offset 0x3b4
+	{value: 0x0010, lo: 0x8d, hi: 0x8f},
+	{value: 0x0054, lo: 0x92, hi: 0x92},
+	{value: 0x0054, lo: 0x95, hi: 0x95},
+	{value: 0x0010, lo: 0xb0, hi: 0xb4},
+	{value: 0x0010, lo: 0xb6, hi: 0xbf},
+	// Block 0x98, offset 0x3b9
+	{value: 0x0010, lo: 0x80, hi: 0xbc},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x99, offset 0x3bb
+	{value: 0x0054, lo: 0x87, hi: 0x87},
+	{value: 0x0054, lo: 0x8e, hi: 0x8e},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0054, lo: 0x9a, hi: 0x9a},
+	{value: 0x5f53, lo: 0xa1, hi: 0xba},
+	{value: 0x0004, lo: 0xbe, hi: 0xbe},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0x9a, offset 0x3c2
+	{value: 0x0004, lo: 0x80, hi: 0x80},
+	{value: 0x5f52, lo: 0x81, hi: 0x9a},
+	{value: 0x0004, lo: 0xb0, hi: 0xb0},
+	// Block 0x9b, offset 0x3c5
+	{value: 0x0014, lo: 0x9e, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xbe},
+	// Block 0x9c, offset 0x3c7
+	{value: 0x0010, lo: 0x82, hi: 0x87},
+	{value: 0x0010, lo: 0x8a, hi: 0x8f},
+	{value: 0x0010, lo: 0x92, hi: 0x97},
+	{value: 0x0010, lo: 0x9a, hi: 0x9c},
+	{value: 0x0004, lo: 0xa3, hi: 0xa3},
+	{value: 0x0014, lo: 0xb9, hi: 0xbb},
+	// Block 0x9d, offset 0x3cd
+	{value: 0x0010, lo: 0x80, hi: 0x8b},
+	{value: 0x0010, lo: 0x8d, hi: 0xa6},
+	{value: 0x0010, lo: 0xa8, hi: 0xba},
+	{value: 0x0010, lo: 0xbc, hi: 0xbd},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0x9e, offset 0x3d2
+	{value: 0x0010, lo: 0x80, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x9d},
+	// Block 0x9f, offset 0x3d4
+	{value: 0x0010, lo: 0x80, hi: 0xba},
+	// Block 0xa0, offset 0x3d5
+	{value: 0x0010, lo: 0x80, hi: 0xb4},
+	// Block 0xa1, offset 0x3d6
+	{value: 0x0034, lo: 0xbd, hi: 0xbd},
+	// Block 0xa2, offset 0x3d7
+	{value: 0x0010, lo: 0x80, hi: 0x9c},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0xa3, offset 0x3d9
+	{value: 0x0010, lo: 0x80, hi: 0x90},
+	{value: 0x0034, lo: 0xa0, hi: 0xa0},
+	// Block 0xa4, offset 0x3db
+	{value: 0x0010, lo: 0x80, hi: 0x9f},
+	{value: 0x0010, lo: 0xad, hi: 0xbf},
+	// Block 0xa5, offset 0x3dd
+	{value: 0x0010, lo: 0x80, hi: 0x8a},
+	{value: 0x0010, lo: 0x90, hi: 0xb5},
+	{value: 0x0024, lo: 0xb6, hi: 0xba},
+	// Block 0xa6, offset 0x3e0
+	{value: 0x0010, lo: 0x80, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0xa7, offset 0x3e2
+	{value: 0x0010, lo: 0x80, hi: 0x83},
+	{value: 0x0010, lo: 0x88, hi: 0x8f},
+	{value: 0x0010, lo: 0x91, hi: 0x95},
+	// Block 0xa8, offset 0x3e5
+	{value: 0x2813, lo: 0x80, hi: 0x87},
+	{value: 0x3813, lo: 0x88, hi: 0x8f},
+	{value: 0x2813, lo: 0x90, hi: 0x97},
+	{value: 0xb653, lo: 0x98, hi: 0x9f},
+	{value: 0xb953, lo: 0xa0, hi: 0xa7},
+	{value: 0x2812, lo: 0xa8, hi: 0xaf},
+	{value: 0x3812, lo: 0xb0, hi: 0xb7},
+	{value: 0x2812, lo: 0xb8, hi: 0xbf},
+	// Block 0xa9, offset 0x3ed
+	{value: 0xb652, lo: 0x80, hi: 0x87},
+	{value: 0xb952, lo: 0x88, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0xbf},
+	// Block 0xaa, offset 0x3f0
+	{value: 0x0010, lo: 0x80, hi: 0x9d},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	{value: 0xb953, lo: 0xb0, hi: 0xb7},
+	{value: 0xb653, lo: 0xb8, hi: 0xbf},
+	// Block 0xab, offset 0x3f4
+	{value: 0x2813, lo: 0x80, hi: 0x87},
+	{value: 0x3813, lo: 0x88, hi: 0x8f},
+	{value: 0x2813, lo: 0x90, hi: 0x93},
+	{value: 0xb952, lo: 0x98, hi: 0x9f},
+	{value: 0xb652, lo: 0xa0, hi: 0xa7},
+	{value: 0x2812, lo: 0xa8, hi: 0xaf},
+	{value: 0x3812, lo: 0xb0, hi: 0xb7},
+	{value: 0x2812, lo: 0xb8, hi: 0xbb},
+	// Block 0xac, offset 0x3fc
+	{value: 0x0010, lo: 0x80, hi: 0xa7},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xad, offset 0x3fe
+	{value: 0x0010, lo: 0x80, hi: 0xa3},
+	{value: 0xbc53, lo: 0xb0, hi: 0xb0},
+	{value: 0xbf53, lo: 0xb1, hi: 0xb1},
+	{value: 0xc253, lo: 0xb2, hi: 0xb2},
+	{value: 0xbf53, lo: 0xb3, hi: 0xb3},
+	{value: 0xc553, lo: 0xb4, hi: 0xb4},
+	{value: 0xbf53, lo: 0xb5, hi: 0xb5},
+	{value: 0xc253, lo: 0xb6, hi: 0xb6},
+	{value: 0xbf53, lo: 0xb7, hi: 0xb7},
+	{value: 0xbc53, lo: 0xb8, hi: 0xb8},
+	{value: 0xc853, lo: 0xb9, hi: 0xb9},
+	{value: 0xcb53, lo: 0xba, hi: 0xba},
+	{value: 0xce53, lo: 0xbc, hi: 0xbc},
+	{value: 0xc853, lo: 0xbd, hi: 0xbd},
+	{value: 0xcb53, lo: 0xbe, hi: 0xbe},
+	{value: 0xc853, lo: 0xbf, hi: 0xbf},
+	// Block 0xae, offset 0x40e
+	{value: 0x0010, lo: 0x80, hi: 0xb6},
+	// Block 0xaf, offset 0x40f
+	{value: 0x0010, lo: 0x80, hi: 0x95},
+	{value: 0x0010, lo: 0xa0, hi: 0xa7},
+	// Block 0xb0, offset 0x411
+	{value: 0x0015, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x82},
+	{value: 0x0015, lo: 0x83, hi: 0x85},
+	{value: 0x0015, lo: 0x87, hi: 0xb0},
+	{value: 0x0015, lo: 0xb2, hi: 0xba},
+	// Block 0xb1, offset 0x416
+	{value: 0x0010, lo: 0x80, hi: 0x85},
+	{value: 0x0010, lo: 0x88, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0xb5},
+	{value: 0x0010, lo: 0xb7, hi: 0xb8},
+	{value: 0x0010, lo: 0xbc, hi: 0xbc},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0xb2, offset 0x41c
+	{value: 0x0010, lo: 0x80, hi: 0x95},
+	{value: 0x0010, lo: 0xa0, hi: 0xb6},
+	// Block 0xb3, offset 0x41e
+	{value: 0x0010, lo: 0x80, hi: 0x9e},
+	// Block 0xb4, offset 0x41f
+	{value: 0x0010, lo: 0xa0, hi: 0xb2},
+	{value: 0x0010, lo: 0xb4, hi: 0xb5},
+	// Block 0xb5, offset 0x421
+	{value: 0x0010, lo: 0x80, hi: 0x95},
+	{value: 0x0010, lo: 0xa0, hi: 0xb9},
+	// Block 0xb6, offset 0x423
+	{value: 0x0010, lo: 0x80, hi: 0x99},
+	// Block 0xb7, offset 0x424
+	{value: 0x0010, lo: 0x80, hi: 0xb7},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0xb8, offset 0x426
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x83},
+	{value: 0x0014, lo: 0x85, hi: 0x86},
+	{value: 0x0014, lo: 0x8c, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x8d},
+	{value: 0x0014, lo: 0x8e, hi: 0x8e},
+	{value: 0x0024, lo: 0x8f, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0x93},
+	{value: 0x0010, lo: 0x95, hi: 0x97},
+	{value: 0x0010, lo: 0x99, hi: 0xb5},
+	{value: 0x0024, lo: 0xb8, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xba},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0xb9, offset 0x433
+	{value: 0x0010, lo: 0xa0, hi: 0xbc},
+	// Block 0xba, offset 0x434
+	{value: 0x0010, lo: 0x80, hi: 0x9c},
+	// Block 0xbb, offset 0x435
+	{value: 0x0010, lo: 0x80, hi: 0x87},
+	{value: 0x0010, lo: 0x89, hi: 0xa4},
+	{value: 0x0024, lo: 0xa5, hi: 0xa5},
+	{value: 0x0034, lo: 0xa6, hi: 0xa6},
+	// Block 0xbc, offset 0x439
+	{value: 0x0010, lo: 0x80, hi: 0x95},
+	{value: 0x0010, lo: 0xa0, hi: 0xb2},
+	// Block 0xbd, offset 0x43b
+	{value: 0x0010, lo: 0x80, hi: 0x91},
+	// Block 0xbe, offset 0x43c
+	{value: 0x0010, lo: 0x80, hi: 0x88},
+	// Block 0xbf, offset 0x43d
+	{value: 0x5653, lo: 0x80, hi: 0xb2},
+	// Block 0xc0, offset 0x43e
+	{value: 0x5652, lo: 0x80, hi: 0xb2},
+	// Block 0xc1, offset 0x43f
+	{value: 0x0010, lo: 0x80, hi: 0xa3},
+	{value: 0x0024, lo: 0xa4, hi: 0xa7},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0xc2, offset 0x442
+	{value: 0x0010, lo: 0x80, hi: 0x8d},
+	{value: 0x0014, lo: 0x8e, hi: 0x8e},
+	{value: 0x0010, lo: 0x8f, hi: 0x8f},
+	{value: 0x2013, lo: 0x90, hi: 0x9f},
+	{value: 0xd153, lo: 0xa0, hi: 0xa5},
+	{value: 0x0024, lo: 0xa9, hi: 0xad},
+	{value: 0x0014, lo: 0xaf, hi: 0xaf},
+	{value: 0x2012, lo: 0xb0, hi: 0xbf},
+	// Block 0xc3, offset 0x44a
+	{value: 0xd152, lo: 0x80, hi: 0x85},
+	// Block 0xc4, offset 0x44b
+	{value: 0x0010, lo: 0x80, hi: 0xa9},
+	{value: 0x0024, lo: 0xab, hi: 0xac},
+	{value: 0x0010, lo: 0xb0, hi: 0xb1},
+	// Block 0xc5, offset 0x44e
+	{value: 0x0010, lo: 0x82, hi: 0x84},
+	{value: 0x0014, lo: 0x85, hi: 0x85},
+	{value: 0x0010, lo: 0x86, hi: 0x87},
+	{value: 0x0034, lo: 0xba, hi: 0xbb},
+	{value: 0x0014, lo: 0xbc, hi: 0xbc},
+	{value: 0x0034, lo: 0xbd, hi: 0xbf},
+	// Block 0xc6, offset 0x454
+	{value: 0x0010, lo: 0x80, hi: 0x9c},
+	{value: 0x0010, lo: 0xa7, hi: 0xa7},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xc7, offset 0x457
+	{value: 0x0010, lo: 0x80, hi: 0x85},
+	{value: 0x0034, lo: 0x86, hi: 0x87},
+	{value: 0x0024, lo: 0x88, hi: 0x8a},
+	{value: 0x0034, lo: 0x8b, hi: 0x8b},
+	{value: 0x0024, lo: 0x8c, hi: 0x8c},
+	{value: 0x0034, lo: 0x8d, hi: 0x90},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xc8, offset 0x45e
+	{value: 0x0010, lo: 0x80, hi: 0x81},
+	{value: 0x0024, lo: 0x82, hi: 0x82},
+	{value: 0x0034, lo: 0x83, hi: 0x83},
+	{value: 0x0024, lo: 0x84, hi: 0x84},
+	{value: 0x0034, lo: 0x85, hi: 0x85},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xc9, offset 0x464
+	{value: 0x0010, lo: 0x80, hi: 0x84},
+	{value: 0x0010, lo: 0xa0, hi: 0xb6},
+	// Block 0xca, offset 0x466
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0xb7},
+	{value: 0x0014, lo: 0xb8, hi: 0xbf},
+	// Block 0xcb, offset 0x46a
+	{value: 0x0014, lo: 0x80, hi: 0x85},
+	{value: 0x0034, lo: 0x86, hi: 0x86},
+	{value: 0x0010, lo: 0xa6, hi: 0xaf},
+	{value: 0x0034, lo: 0xb0, hi: 0xb0},
+	{value: 0x0010, lo: 0xb1, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb4},
+	{value: 0x0010, lo: 0xb5, hi: 0xb5},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0xcc, offset 0x472
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb6},
+	{value: 0x0010, lo: 0xb7, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xba},
+	{value: 0x0014, lo: 0xbd, hi: 0xbd},
+	// Block 0xcd, offset 0x478
+	{value: 0x0014, lo: 0x82, hi: 0x82},
+	{value: 0x0014, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0xa8},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0xce, offset 0x47c
+	{value: 0x0024, lo: 0x80, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0xa6},
+	{value: 0x0014, lo: 0xa7, hi: 0xab},
+	{value: 0x0010, lo: 0xac, hi: 0xac},
+	{value: 0x0014, lo: 0xad, hi: 0xb2},
+	{value: 0x0034, lo: 0xb3, hi: 0xb4},
+	{value: 0x0010, lo: 0xb6, hi: 0xbf},
+	// Block 0xcf, offset 0x483
+	{value: 0x0010, lo: 0x84, hi: 0x87},
+	{value: 0x0010, lo: 0x90, hi: 0xb2},
+	{value: 0x0034, lo: 0xb3, hi: 0xb3},
+	{value: 0x0010, lo: 0xb6, hi: 0xb6},
+	// Block 0xd0, offset 0x487
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0xb5},
+	{value: 0x0014, lo: 0xb6, hi: 0xbe},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0xd1, offset 0x48b
+	{value: 0x0030, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x84},
+	{value: 0x0014, lo: 0x89, hi: 0x89},
+	{value: 0x0034, lo: 0x8a, hi: 0x8a},
+	{value: 0x0014, lo: 0x8b, hi: 0x8c},
+	{value: 0x0010, lo: 0x8e, hi: 0x8e},
+	{value: 0x0014, lo: 0x8f, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0x9a},
+	{value: 0x0010, lo: 0x9c, hi: 0x9c},
+	// Block 0xd2, offset 0x494
+	{value: 0x0010, lo: 0x80, hi: 0x91},
+	{value: 0x0010, lo: 0x93, hi: 0xae},
+	{value: 0x0014, lo: 0xaf, hi: 0xb1},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	{value: 0x0014, lo: 0xb4, hi: 0xb4},
+	{value: 0x0030, lo: 0xb5, hi: 0xb5},
+	{value: 0x0034, lo: 0xb6, hi: 0xb6},
+	{value: 0x0014, lo: 0xb7, hi: 0xb7},
+	{value: 0x0014, lo: 0xbe, hi: 0xbe},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0xd3, offset 0x49e
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	// Block 0xd4, offset 0x4a0
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0010, lo: 0x88, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0x8d},
+	{value: 0x0010, lo: 0x8f, hi: 0x9d},
+	{value: 0x0010, lo: 0x9f, hi: 0xa8},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xd5, offset 0x4a6
+	{value: 0x0010, lo: 0x80, hi: 0x9e},
+	{value: 0x0014, lo: 0x9f, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xa2},
+	{value: 0x0014, lo: 0xa3, hi: 0xa8},
+	{value: 0x0034, lo: 0xa9, hi: 0xaa},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0xd6, offset 0x4ac
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x8c},
+	{value: 0x0010, lo: 0x8f, hi: 0x90},
+	{value: 0x0010, lo: 0x93, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb2, hi: 0xb3},
+	{value: 0x0010, lo: 0xb5, hi: 0xb9},
+	{value: 0x0034, lo: 0xbb, hi: 0xbc},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0xd7, offset 0x4b6
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x84},
+	{value: 0x0010, lo: 0x87, hi: 0x88},
+	{value: 0x0010, lo: 0x8b, hi: 0x8c},
+	{value: 0x0030, lo: 0x8d, hi: 0x8d},
+	{value: 0x0010, lo: 0x90, hi: 0x90},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0010, lo: 0x9d, hi: 0xa3},
+	{value: 0x0024, lo: 0xa6, hi: 0xac},
+	{value: 0x0024, lo: 0xb0, hi: 0xb4},
+	// Block 0xd8, offset 0x4c0
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x8b, hi: 0x8b},
+	{value: 0x0010, lo: 0x8e, hi: 0x8e},
+	{value: 0x0010, lo: 0x90, hi: 0xb5},
+	{value: 0x0010, lo: 0xb7, hi: 0xba},
+	{value: 0x0014, lo: 0xbb, hi: 0xbf},
+	// Block 0xd9, offset 0x4c6
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x82, hi: 0x82},
+	{value: 0x0010, lo: 0x85, hi: 0x85},
+	{value: 0x0010, lo: 0x87, hi: 0x8a},
+	{value: 0x0010, lo: 0x8c, hi: 0x8d},
+	{value: 0x0034, lo: 0x8e, hi: 0x8e},
+	{value: 0x0030, lo: 0x8f, hi: 0x8f},
+	{value: 0x0034, lo: 0x90, hi: 0x90},
+	{value: 0x0010, lo: 0x91, hi: 0x91},
+	{value: 0x0014, lo: 0x92, hi: 0x92},
+	{value: 0x0010, lo: 0x93, hi: 0x93},
+	{value: 0x0014, lo: 0xa1, hi: 0xa2},
+	// Block 0xda, offset 0x4d2
+	{value: 0x0010, lo: 0x80, hi: 0xb7},
+	{value: 0x0014, lo: 0xb8, hi: 0xbf},
+	// Block 0xdb, offset 0x4d4
+	{value: 0x0010, lo: 0x80, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x82},
+	{value: 0x0014, lo: 0x83, hi: 0x84},
+	{value: 0x0010, lo: 0x85, hi: 0x85},
+	{value: 0x0034, lo: 0x86, hi: 0x86},
+	{value: 0x0010, lo: 0x87, hi: 0x8a},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0024, lo: 0x9e, hi: 0x9e},
+	{value: 0x0010, lo: 0x9f, hi: 0xa1},
+	// Block 0xdc, offset 0x4dd
+	{value: 0x0010, lo: 0x80, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb8},
+	{value: 0x0010, lo: 0xb9, hi: 0xb9},
+	{value: 0x0014, lo: 0xba, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbe},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0xdd, offset 0x4e3
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x83},
+	{value: 0x0010, lo: 0x84, hi: 0x85},
+	{value: 0x0010, lo: 0x87, hi: 0x87},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0xde, offset 0x4e9
+	{value: 0x0010, lo: 0x80, hi: 0xb1},
+	{value: 0x0014, lo: 0xb2, hi: 0xb5},
+	{value: 0x0010, lo: 0xb8, hi: 0xbb},
+	{value: 0x0014, lo: 0xbc, hi: 0xbd},
+	{value: 0x0010, lo: 0xbe, hi: 0xbe},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0xdf, offset 0x4ef
+	{value: 0x0034, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x98, hi: 0x9b},
+	{value: 0x0014, lo: 0x9c, hi: 0x9d},
+	// Block 0xe0, offset 0x4f2
+	{value: 0x0010, lo: 0x80, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xba},
+	{value: 0x0010, lo: 0xbb, hi: 0xbc},
+	{value: 0x0014, lo: 0xbd, hi: 0xbd},
+	{value: 0x0010, lo: 0xbe, hi: 0xbe},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0xe1, offset 0x4f8
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x84, hi: 0x84},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0xe2, offset 0x4fb
+	{value: 0x0010, lo: 0x80, hi: 0xaa},
+	{value: 0x0014, lo: 0xab, hi: 0xab},
+	{value: 0x0010, lo: 0xac, hi: 0xac},
+	{value: 0x0014, lo: 0xad, hi: 0xad},
+	{value: 0x0010, lo: 0xae, hi: 0xaf},
+	{value: 0x0014, lo: 0xb0, hi: 0xb5},
+	{value: 0x0030, lo: 0xb6, hi: 0xb6},
+	{value: 0x0034, lo: 0xb7, hi: 0xb7},
+	{value: 0x0010, lo: 0xb8, hi: 0xb8},
+	// Block 0xe3, offset 0x504
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x90, hi: 0xa3},
+	// Block 0xe4, offset 0x506
+	{value: 0x0014, lo: 0x9d, hi: 0x9d},
+	{value: 0x0010, lo: 0x9e, hi: 0x9e},
+	{value: 0x0014, lo: 0x9f, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa5},
+	{value: 0x0010, lo: 0xa6, hi: 0xa6},
+	{value: 0x0014, lo: 0xa7, hi: 0xaa},
+	{value: 0x0034, lo: 0xab, hi: 0xab},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0xe5, offset 0x50f
+	{value: 0x0010, lo: 0x80, hi: 0xae},
+	{value: 0x0014, lo: 0xaf, hi: 0xb7},
+	{value: 0x0010, lo: 0xb8, hi: 0xb8},
+	{value: 0x0034, lo: 0xb9, hi: 0xba},
+	// Block 0xe6, offset 0x513
+	{value: 0x5f53, lo: 0xa0, hi: 0xbf},
+	// Block 0xe7, offset 0x514
+	{value: 0x5f52, lo: 0x80, hi: 0x9f},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0xe8, offset 0x517
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0010, lo: 0x89, hi: 0x89},
+	{value: 0x0010, lo: 0x8c, hi: 0x93},
+	{value: 0x0010, lo: 0x95, hi: 0x96},
+	{value: 0x0010, lo: 0x98, hi: 0xb5},
+	{value: 0x0010, lo: 0xb7, hi: 0xb8},
+	{value: 0x0014, lo: 0xbb, hi: 0xbc},
+	{value: 0x0030, lo: 0xbd, hi: 0xbd},
+	{value: 0x0034, lo: 0xbe, hi: 0xbe},
+	{value: 0x0010, lo: 0xbf, hi: 0xbf},
+	// Block 0xe9, offset 0x521
+	{value: 0x0010, lo: 0x80, hi: 0x82},
+	{value: 0x0034, lo: 0x83, hi: 0x83},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0xea, offset 0x524
+	{value: 0x0010, lo: 0xa0, hi: 0xa7},
+	{value: 0x0010, lo: 0xaa, hi: 0xbf},
+	// Block 0xeb, offset 0x526
+	{value: 0x0010, lo: 0x80, hi: 0x93},
+	{value: 0x0014, lo: 0x94, hi: 0x97},
+	{value: 0x0014, lo: 0x9a, hi: 0x9b},
+	{value: 0x0010, lo: 0x9c, hi: 0x9f},
+	{value: 0x0034, lo: 0xa0, hi: 0xa0},
+	{value: 0x0010, lo: 0xa1, hi: 0xa1},
+	{value: 0x0010, lo: 0xa3, hi: 0xa4},
+	// Block 0xec, offset 0x52d
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0014, lo: 0x81, hi: 0x8a},
+	{value: 0x0010, lo: 0x8b, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb3},
+	{value: 0x0034, lo: 0xb4, hi: 0xb4},
+	{value: 0x0014, lo: 0xb5, hi: 0xb8},
+	{value: 0x0010, lo: 0xb9, hi: 0xba},
+	{value: 0x0014, lo: 0xbb, hi: 0xbe},
+	// Block 0xed, offset 0x535
+	{value: 0x0034, lo: 0x87, hi: 0x87},
+	{value: 0x0010, lo: 0x90, hi: 0x90},
+	{value: 0x0014, lo: 0x91, hi: 0x96},
+	{value: 0x0010, lo: 0x97, hi: 0x98},
+	{value: 0x0014, lo: 0x99, hi: 0x9b},
+	{value: 0x0010, lo: 0x9c, hi: 0xbf},
+	// Block 0xee, offset 0x53b
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0014, lo: 0x8a, hi: 0x96},
+	{value: 0x0010, lo: 0x97, hi: 0x97},
+	{value: 0x0014, lo: 0x98, hi: 0x98},
+	{value: 0x0034, lo: 0x99, hi: 0x99},
+	{value: 0x0010, lo: 0x9d, hi: 0x9d},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xef, offset 0x542
+	{value: 0x0010, lo: 0x80, hi: 0xb8},
+	// Block 0xf0, offset 0x543
+	{value: 0x0014, lo: 0xa0, hi: 0xa0},
+	{value: 0x0010, lo: 0xa1, hi: 0xa1},
+	{value: 0x0014, lo: 0xa2, hi: 0xa4},
+	{value: 0x0010, lo: 0xa5, hi: 0xa5},
+	{value: 0x0014, lo: 0xa6, hi: 0xa6},
+	{value: 0x0010, lo: 0xa7, hi: 0xa7},
+	// Block 0xf1, offset 0x549
+	{value: 0x0010, lo: 0x80, hi: 0xa0},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0xf2, offset 0x54b
+	{value: 0x0010, lo: 0x80, hi: 0x88},
+	{value: 0x0010, lo: 0x8a, hi: 0xaf},
+	{value: 0x0014, lo: 0xb0, hi: 0xb6},
+	{value: 0x0014, lo: 0xb8, hi: 0xbd},
+	{value: 0x0010, lo: 0xbe, hi: 0xbe},
+	{value: 0x0034, lo: 0xbf, hi: 0xbf},
+	// Block 0xf3, offset 0x551
+	{value: 0x0010, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0010, lo: 0xb2, hi: 0xbf},
+	// Block 0xf4, offset 0x554
+	{value: 0x0010, lo: 0x80, hi: 0x8f},
+	{value: 0x0014, lo: 0x92, hi: 0xa7},
+	{value: 0x0010, lo: 0xa9, hi: 0xa9},
+	{value: 0x0014, lo: 0xaa, hi: 0xb0},
+	{value: 0x0010, lo: 0xb1, hi: 0xb1},
+	{value: 0x0014, lo: 0xb2, hi: 0xb3},
+	{value: 0x0010, lo: 0xb4, hi: 0xb4},
+	{value: 0x0014, lo: 0xb5, hi: 0xb6},
+	// Block 0xf5, offset 0x55c
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	{value: 0x0010, lo: 0x88, hi: 0x89},
+	{value: 0x0010, lo: 0x8b, hi: 0xb0},
+	{value: 0x0014, lo: 0xb1, hi: 0xb6},
+	{value: 0x0014, lo: 0xba, hi: 0xba},
+	{value: 0x0014, lo: 0xbc, hi: 0xbd},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0xf6, offset 0x563
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x82},
+	{value: 0x0014, lo: 0x83, hi: 0x83},
+	{value: 0x0034, lo: 0x84, hi: 0x85},
+	{value: 0x0010, lo: 0x86, hi: 0x86},
+	{value: 0x0014, lo: 0x87, hi: 0x87},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0010, lo: 0xa0, hi: 0xa5},
+	{value: 0x0010, lo: 0xa7, hi: 0xa8},
+	{value: 0x0010, lo: 0xaa, hi: 0xbf},
+	// Block 0xf7, offset 0x56d
+	{value: 0x0010, lo: 0x80, hi: 0x8e},
+	{value: 0x0014, lo: 0x90, hi: 0x91},
+	{value: 0x0010, lo: 0x93, hi: 0x94},
+	{value: 0x0014, lo: 0x95, hi: 0x95},
+	{value: 0x0010, lo: 0x96, hi: 0x96},
+	{value: 0x0034, lo: 0x97, hi: 0x97},
+	{value: 0x0010, lo: 0x98, hi: 0x98},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0xf8, offset 0x576
+	{value: 0x0010, lo: 0x80, hi: 0x98},
+	{value: 0x0014, lo: 0x99, hi: 0x99},
+	{value: 0x0010, lo: 0x9a, hi: 0x9b},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	// Block 0xf9, offset 0x57a
+	{value: 0x0010, lo: 0xa0, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xb4},
+	{value: 0x0010, lo: 0xb5, hi: 0xb6},
+	// Block 0xfa, offset 0x57d
+	{value: 0x0014, lo: 0x80, hi: 0x81},
+	{value: 0x0010, lo: 0x82, hi: 0x90},
+	{value: 0x0010, lo: 0x92, hi: 0xb5},
+	{value: 0x0014, lo: 0xb6, hi: 0xba},
+	{value: 0x0010, lo: 0xbe, hi: 0xbf},
+	// Block 0xfb, offset 0x582
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0030, lo: 0x81, hi: 0x81},
+	{value: 0x0034, lo: 0x82, hi: 0x82},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0014, lo: 0x9a, hi: 0x9a},
+	// Block 0xfc, offset 0x587
+	{value: 0x0010, lo: 0xb0, hi: 0xb0},
+	// Block 0xfd, offset 0x588
+	{value: 0x0010, lo: 0x80, hi: 0xae},
+	// Block 0xfe, offset 0x589
+	{value: 0x0010, lo: 0x80, hi: 0x83},
+	// Block 0xff, offset 0x58a
+	{value: 0x0010, lo: 0x80, hi: 0xb0},
+	// Block 0x100, offset 0x58b
+	{value: 0x0010, lo: 0x80, hi: 0xaf},
+	{value: 0x0014, lo: 0xb0, hi: 0xbf},
+	// Block 0x101, offset 0x58d
+	{value: 0x0014, lo: 0x80, hi: 0x80},
+	{value: 0x0010, lo: 0x81, hi: 0x86},
+	{value: 0x0014, lo: 0x87, hi: 0x95},
+	{value: 0x0010, lo: 0xa0, hi: 0xbf},
+	// Block 0x102, offset 0x591
+	{value: 0x0010, lo: 0x80, hi: 0x86},
+	// Block 0x103, offset 0x592
+	{value: 0x0010, lo: 0x80, hi: 0x9d},
+	{value: 0x0014, lo: 0x9e, hi: 0xa9},
+	{value: 0x0010, lo: 0xaa, hi: 0xac},
+	{value: 0x0014, lo: 0xad, hi: 0xae},
+	{value: 0x0034, lo: 0xaf, hi: 0xaf},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x104, offset 0x598
+	{value: 0x0010, lo: 0x80, hi: 0x9e},
+	{value: 0x0010, lo: 0xa0, hi: 0xa9},
+	{value: 0x0010, lo: 0xb0, hi: 0xbf},
+	// Block 0x105, offset 0x59b
+	{value: 0x0010, lo: 0x80, hi: 0xbe},
+	// Block 0x106, offset 0x59c
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x90, hi: 0xad},
+	{value: 0x0034, lo: 0xb0, hi: 0xb4},
+	// Block 0x107, offset 0x59f
+	{value: 0x0010, lo: 0x80, hi: 0xaf},
+	{value: 0x0024, lo: 0xb0, hi: 0xb6},
+	// Block 0x108, offset 0x5a1
+	{value: 0x0014, lo: 0x80, hi: 0x83},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0010, lo: 0xa3, hi: 0xb7},
+	{value: 0x0010, lo: 0xbd, hi: 0xbf},
+	// Block 0x109, offset 0x5a5
+	{value: 0x0010, lo: 0x80, hi: 0x8f},
+	// Block 0x10a, offset 0x5a6
+	{value: 0x0014, lo: 0x80, hi: 0x82},
+	{value: 0x0010, lo: 0x83, hi: 0xaa},
+	{value: 0x0014, lo: 0xab, hi: 0xac},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x10b, offset 0x5aa
+	{value: 0x2013, lo: 0x80, hi: 0x9f},
+	{value: 0x2012, lo: 0xa0, hi: 0xbf},
+	// Block 0x10c, offset 0x5ac
+	{value: 0x0010, lo: 0x80, hi: 0x8a},
+	{value: 0x0014, lo: 0x8f, hi: 0x8f},
+	{value: 0x0010, lo: 0x90, hi: 0xbf},
+	// Block 0x10d, offset 0x5af
+	{value: 0x0010, lo: 0x80, hi: 0x87},
+	{value: 0x0014, lo: 0x8f, hi: 0x9f},
+	// Block 0x10e, offset 0x5b1
+	{value: 0x0014, lo: 0xa0, hi: 0xa1},
+	{value: 0x0014, lo: 0xa3, hi: 0xa4},
+	{value: 0x0030, lo: 0xb0, hi: 0xb1},
+	{value: 0x0004, lo: 0xb2, hi: 0xb3},
+	// Block 0x10f, offset 0x5b5
+	{value: 0x0004, lo: 0xb0, hi: 0xb3},
+	{value: 0x0004, lo: 0xb5, hi: 0xbb},
+	{value: 0x0004, lo: 0xbd, hi: 0xbe},
+	// Block 0x110, offset 0x5b8
+	{value: 0x0010, lo: 0x80, hi: 0xaa},
+	{value: 0x0010, lo: 0xb0, hi: 0xbc},
+	// Block 0x111, offset 0x5ba
+	{value: 0x0010, lo: 0x80, hi: 0x88},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	{value: 0x0014, lo: 0x9d, hi: 0x9d},
+	{value: 0x0034, lo: 0x9e, hi: 0x9e},
+	{value: 0x0014, lo: 0xa0, hi: 0xa3},
+	// Block 0x112, offset 0x5bf
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x113, offset 0x5c0
+	{value: 0x0014, lo: 0x80, hi: 0xad},
+	{value: 0x0014, lo: 0xb0, hi: 0xbf},
+	// Block 0x114, offset 0x5c2
+	{value: 0x0014, lo: 0x80, hi: 0x86},
+	// Block 0x115, offset 0x5c3
+	{value: 0x0030, lo: 0xa5, hi: 0xa6},
+	{value: 0x0034, lo: 0xa7, hi: 0xa9},
+	{value: 0x0030, lo: 0xad, hi: 0xb2},
+	{value: 0x0014, lo: 0xb3, hi: 0xba},
+	{value: 0x0034, lo: 0xbb, hi: 0xbf},
+	// Block 0x116, offset 0x5c8
+	{value: 0x0034, lo: 0x80, hi: 0x82},
+	{value: 0x0024, lo: 0x85, hi: 0x89},
+	{value: 0x0034, lo: 0x8a, hi: 0x8b},
+	{value: 0x0024, lo: 0xaa, hi: 0xad},
+	// Block 0x117, offset 0x5cc
+	{value: 0x0024, lo: 0x82, hi: 0x84},
+	// Block 0x118, offset 0x5cd
+	{value: 0x0013, lo: 0x80, hi: 0x99},
+	{value: 0x0012, lo: 0x9a, hi: 0xb3},
+	{value: 0x0013, lo: 0xb4, hi: 0xbf},
+	// Block 0x119, offset 0x5d0
+	{value: 0x0013, lo: 0x80, hi: 0x8d},
+	{value: 0x0012, lo: 0x8e, hi: 0x94},
+	{value: 0x0012, lo: 0x96, hi: 0xa7},
+	{value: 0x0013, lo: 0xa8, hi: 0xbf},
+	// Block 0x11a, offset 0x5d4
+	{value: 0x0013, lo: 0x80, hi: 0x81},
+	{value: 0x0012, lo: 0x82, hi: 0x9b},
+	{value: 0x0013, lo: 0x9c, hi: 0x9c},
+	{value: 0x0013, lo: 0x9e, hi: 0x9f},
+	{value: 0x0013, lo: 0xa2, hi: 0xa2},
+	{value: 0x0013, lo: 0xa5, hi: 0xa6},
+	{value: 0x0013, lo: 0xa9, hi: 0xac},
+	{value: 0x0013, lo: 0xae, hi: 0xb5},
+	{value: 0x0012, lo: 0xb6, hi: 0xb9},
+	{value: 0x0012, lo: 0xbb, hi: 0xbb},
+	{value: 0x0012, lo: 0xbd, hi: 0xbf},
+	// Block 0x11b, offset 0x5df
+	{value: 0x0012, lo: 0x80, hi: 0x83},
+	{value: 0x0012, lo: 0x85, hi: 0x8f},
+	{value: 0x0013, lo: 0x90, hi: 0xa9},
+	{value: 0x0012, lo: 0xaa, hi: 0xbf},
+	// Block 0x11c, offset 0x5e3
+	{value: 0x0012, lo: 0x80, hi: 0x83},
+	{value: 0x0013, lo: 0x84, hi: 0x85},
+	{value: 0x0013, lo: 0x87, hi: 0x8a},
+	{value: 0x0013, lo: 0x8d, hi: 0x94},
+	{value: 0x0013, lo: 0x96, hi: 0x9c},
+	{value: 0x0012, lo: 0x9e, hi: 0xb7},
+	{value: 0x0013, lo: 0xb8, hi: 0xb9},
+	{value: 0x0013, lo: 0xbb, hi: 0xbe},
+	// Block 0x11d, offset 0x5eb
+	{value: 0x0013, lo: 0x80, hi: 0x84},
+	{value: 0x0013, lo: 0x86, hi: 0x86},
+	{value: 0x0013, lo: 0x8a, hi: 0x90},
+	{value: 0x0012, lo: 0x92, hi: 0xab},
+	{value: 0x0013, lo: 0xac, hi: 0xbf},
+	// Block 0x11e, offset 0x5f0
+	{value: 0x0013, lo: 0x80, hi: 0x85},
+	{value: 0x0012, lo: 0x86, hi: 0x9f},
+	{value: 0x0013, lo: 0xa0, hi: 0xb9},
+	{value: 0x0012, lo: 0xba, hi: 0xbf},
+	// Block 0x11f, offset 0x5f4
+	{value: 0x0012, lo: 0x80, hi: 0x93},
+	{value: 0x0013, lo: 0x94, hi: 0xad},
+	{value: 0x0012, lo: 0xae, hi: 0xbf},
+	// Block 0x120, offset 0x5f7
+	{value: 0x0012, lo: 0x80, hi: 0x87},
+	{value: 0x0013, lo: 0x88, hi: 0xa1},
+	{value: 0x0012, lo: 0xa2, hi: 0xbb},
+	{value: 0x0013, lo: 0xbc, hi: 0xbf},
+	// Block 0x121, offset 0x5fb
+	{value: 0x0013, lo: 0x80, hi: 0x95},
+	{value: 0x0012, lo: 0x96, hi: 0xaf},
+	{value: 0x0013, lo: 0xb0, hi: 0xbf},
+	// Block 0x122, offset 0x5fe
+	{value: 0x0013, lo: 0x80, hi: 0x89},
+	{value: 0x0012, lo: 0x8a, hi: 0xa5},
+	{value: 0x0013, lo: 0xa8, hi: 0xbf},
+	// Block 0x123, offset 0x601
+	{value: 0x0013, lo: 0x80, hi: 0x80},
+	{value: 0x0012, lo: 0x82, hi: 0x9a},
+	{value: 0x0012, lo: 0x9c, hi: 0xa1},
+	{value: 0x0013, lo: 0xa2, hi: 0xba},
+	{value: 0x0012, lo: 0xbc, hi: 0xbf},
+	// Block 0x124, offset 0x606
+	{value: 0x0012, lo: 0x80, hi: 0x94},
+	{value: 0x0012, lo: 0x96, hi: 0x9b},
+	{value: 0x0013, lo: 0x9c, hi: 0xb4},
+	{value: 0x0012, lo: 0xb6, hi: 0xbf},
+	// Block 0x125, offset 0x60a
+	{value: 0x0012, lo: 0x80, hi: 0x8e},
+	{value: 0x0012, lo: 0x90, hi: 0x95},
+	{value: 0x0013, lo: 0x96, hi: 0xae},
+	{value: 0x0012, lo: 0xb0, hi: 0xbf},
+	// Block 0x126, offset 0x60e
+	{value: 0x0012, lo: 0x80, hi: 0x88},
+	{value: 0x0012, lo: 0x8a, hi: 0x8f},
+	{value: 0x0013, lo: 0x90, hi: 0xa8},
+	{value: 0x0012, lo: 0xaa, hi: 0xbf},
+	// Block 0x127, offset 0x612
+	{value: 0x0012, lo: 0x80, hi: 0x82},
+	{value: 0x0012, lo: 0x84, hi: 0x89},
+	{value: 0x0017, lo: 0x8a, hi: 0x8b},
+	{value: 0x0010, lo: 0x8e, hi: 0xbf},
+	// Block 0x128, offset 0x616
+	{value: 0x0014, lo: 0x80, hi: 0xb6},
+	{value: 0x0014, lo: 0xbb, hi: 0xbf},
+	// Block 0x129, offset 0x618
+	{value: 0x0014, lo: 0x80, hi: 0xac},
+	{value: 0x0014, lo: 0xb5, hi: 0xb5},
+	// Block 0x12a, offset 0x61a
+	{value: 0x0014, lo: 0x84, hi: 0x84},
+	{value: 0x0014, lo: 0x9b, hi: 0x9f},
+	{value: 0x0014, lo: 0xa1, hi: 0xaf},
+	// Block 0x12b, offset 0x61d
+	{value: 0x0012, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x8a, hi: 0x8a},
+	{value: 0x0012, lo: 0x8b, hi: 0x9e},
+	{value: 0x0012, lo: 0xa5, hi: 0xaa},
+	// Block 0x12c, offset 0x621
+	{value: 0x0024, lo: 0x80, hi: 0x86},
+	{value: 0x0024, lo: 0x88, hi: 0x98},
+	{value: 0x0024, lo: 0x9b, hi: 0xa1},
+	{value: 0x0024, lo: 0xa3, hi: 0xa4},
+	{value: 0x0024, lo: 0xa6, hi: 0xaa},
+	{value: 0x0015, lo: 0xb0, hi: 0xbf},
+	// Block 0x12d, offset 0x627
+	{value: 0x0015, lo: 0x80, hi: 0xad},
+	// Block 0x12e, offset 0x628
+	{value: 0x0024, lo: 0x8f, hi: 0x8f},
+	// Block 0x12f, offset 0x629
+	{value: 0x0010, lo: 0x80, hi: 0xac},
+	{value: 0x0024, lo: 0xb0, hi: 0xb6},
+	{value: 0x0014, lo: 0xb7, hi: 0xbd},
+	// Block 0x130, offset 0x62c
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x8e, hi: 0x8e},
+	// Block 0x131, offset 0x62e
+	{value: 0x0010, lo: 0x90, hi: 0xad},
+	{value: 0x0024, lo: 0xae, hi: 0xae},
+	// Block 0x132, offset 0x630
+	{value: 0x0010, lo: 0x80, hi: 0xab},
+	{value: 0x0024, lo: 0xac, hi: 0xaf},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x133, offset 0x633
+	{value: 0x0010, lo: 0x90, hi: 0xaa},
+	{value: 0x0014, lo: 0xab, hi: 0xab},
+	{value: 0x0034, lo: 0xac, hi: 0xae},
+	{value: 0x0024, lo: 0xaf, hi: 0xaf},
+	{value: 0x0010, lo: 0xb0, hi: 0xb9},
+	// Block 0x134, offset 0x638
+	{value: 0x0010, lo: 0x90, hi: 0xad},
+	{value: 0x0024, lo: 0xae, hi: 0xae},
+	{value: 0x0034, lo: 0xaf, hi: 0xaf},
+	{value: 0x0010, lo: 0xb0, hi: 0xba},
+	// Block 0x135, offset 0x63c
+	{value: 0x0010, lo: 0x80, hi: 0x9e},
+	{value: 0x0010, lo: 0xa0, hi: 0xa2},
+	{value: 0x0024, lo: 0xa3, hi: 0xa3},
+	{value: 0x0010, lo: 0xa4, hi: 0xa5},
+	{value: 0x0024, lo: 0xa6, hi: 0xa6},
+	{value: 0x0010, lo: 0xa7, hi: 0xad},
+	{value: 0x0024, lo: 0xae, hi: 0xaf},
+	{value: 0x0010, lo: 0xb0, hi: 0xb4},
+	{value: 0x0024, lo: 0xb5, hi: 0xb5},
+	{value: 0x0010, lo: 0xbe, hi: 0xbe},
+	{value: 0x0014, lo: 0xbf, hi: 0xbf},
+	// Block 0x136, offset 0x647
+	{value: 0x0010, lo: 0xa0, hi: 0xa6},
+	{value: 0x0010, lo: 0xa8, hi: 0xab},
+	{value: 0x0010, lo: 0xad, hi: 0xae},
+	{value: 0x0010, lo: 0xb0, hi: 0xbe},
+	// Block 0x137, offset 0x64b
+	{value: 0x0010, lo: 0x80, hi: 0x84},
+	{value: 0x0034, lo: 0x90, hi: 0x96},
+	// Block 0x138, offset 0x64d
+	{value: 0xe952, lo: 0x80, hi: 0x81},
+	{value: 0xec52, lo: 0x82, hi: 0x83},
+	{value: 0x0024, lo: 0x84, hi: 0x89},
+	{value: 0x0034, lo: 0x8a, hi: 0x8a},
+	{value: 0x0014, lo: 0x8b, hi: 0x8b},
+	{value: 0x0010, lo: 0x90, hi: 0x99},
+	// Block 0x139, offset 0x653
+	{value: 0x0010, lo: 0x80, hi: 0x83},
+	{value: 0x0010, lo: 0x85, hi: 0x9f},
+	{value: 0x0010, lo: 0xa1, hi: 0xa2},
+	{value: 0x0010, lo: 0xa4, hi: 0xa4},
+	{value: 0x0010, lo: 0xa7, hi: 0xa7},
+	{value: 0x0010, lo: 0xa9, hi: 0xb2},
+	{value: 0x0010, lo: 0xb4, hi: 0xb7},
+	{value: 0x0010, lo: 0xb9, hi: 0xb9},
+	{value: 0x0010, lo: 0xbb, hi: 0xbb},
+	// Block 0x13a, offset 0x65c
+	{value: 0x0010, lo: 0x80, hi: 0x89},
+	{value: 0x0010, lo: 0x8b, hi: 0x9b},
+	{value: 0x0010, lo: 0xa1, hi: 0xa3},
+	{value: 0x0010, lo: 0xa5, hi: 0xa9},
+	{value: 0x0010, lo: 0xab, hi: 0xbb},
+	// Block 0x13b, offset 0x661
+	{value: 0x0013, lo: 0xb0, hi: 0xbf},
+	// Block 0x13c, offset 0x662
+	{value: 0x0013, lo: 0x80, hi: 0x89},
+	{value: 0x0013, lo: 0x90, hi: 0xa9},
+	{value: 0x0013, lo: 0xb0, hi: 0xbf},
+	// Block 0x13d, offset 0x665
+	{value: 0x0013, lo: 0x80, hi: 0x89},
+	// Block 0x13e, offset 0x666
+	{value: 0x0014, lo: 0xbb, hi: 0xbf},
+	// Block 0x13f, offset 0x667
+	{value: 0x0014, lo: 0x81, hi: 0x81},
+	{value: 0x0014, lo: 0xa0, hi: 0xbf},
+	// Block 0x140, offset 0x669
+	{value: 0x0014, lo: 0x80, hi: 0xbf},
+	// Block 0x141, offset 0x66a
+	{value: 0x0014, lo: 0x80, hi: 0xaf},
+}
+
+// Total table size 16747 bytes (16KiB); checksum: D520269F
diff --git a/vendor/golang.org/x/text/cases/trieval.go b/vendor/golang.org/x/text/cases/trieval.go
new file mode 100644
index 00000000000..4e4d13fe5d1
--- /dev/null
+++ b/vendor/golang.org/x/text/cases/trieval.go
@@ -0,0 +1,217 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+package cases
+
+// This file contains definitions for interpreting the trie value of the case
+// trie generated by "go run gen*.go". It is shared by both the generator
+// program and the resultant package. Sharing is achieved by the generator
+// copying gen_trieval.go to trieval.go and changing what's above this comment.
+
+// info holds case information for a single rune. It is the value returned
+// by a trie lookup. Most mapping information can be stored in a single 16-bit
+// value. If not, for example when a rune is mapped to multiple runes, the value
+// stores some basic case data and an index into an array with additional data.
+//
+// The per-rune values have the following format:
+//
+//	if (exception) {
+//	  15..4  unsigned exception index
+//	} else {
+//	  15..8  XOR pattern or index to XOR pattern for case mapping
+//	         Only 13..8 are used for XOR patterns.
+//	      7  inverseFold (fold to upper, not to lower)
+//	      6  index: interpret the XOR pattern as an index
+//	         or isMid if case mode is cIgnorableUncased.
+//	   5..4  CCC: zero (normal or break), above or other
+//	}
+//	   3  exception: interpret this value as an exception index
+//	      (TODO: is this bit necessary? Probably implied from case mode.)
+//	2..0  case mode
+//
+// For the non-exceptional cases, a rune must be either uncased, lowercase or
+// uppercase. If the rune is cased, the XOR pattern maps either a lowercase
+// rune to uppercase or an uppercase rune to lowercase (applied to the 10
+// least-significant bits of the rune).
+//
+// See the definitions below for a more detailed description of the various
+// bits.
+type info uint16
+
+const (
+	casedMask      = 0x0003
+	fullCasedMask  = 0x0007
+	ignorableMask  = 0x0006
+	ignorableValue = 0x0004
+
+	inverseFoldBit = 1 << 7
+	isMidBit       = 1 << 6
+
+	exceptionBit     = 1 << 3
+	exceptionShift   = 4
+	numExceptionBits = 12
+
+	xorIndexBit = 1 << 6
+	xorShift    = 8
+
+	// There is no mapping if all xor bits and the exception bit are zero.
+	hasMappingMask = 0xff80 | exceptionBit
+)
+
+// The case mode bits encodes the case type of a rune. This includes uncased,
+// title, upper and lower case and case ignorable. (For a definition of these
+// terms see Chapter 3 of The Unicode Standard Core Specification.) In some rare
+// cases, a rune can be both cased and case-ignorable. This is encoded by
+// cIgnorableCased. A rune of this type is always lower case. Some runes are
+// cased while not having a mapping.
+//
+// A common pattern for scripts in the Unicode standard is for upper and lower
+// case runes to alternate for increasing rune values (e.g. the accented Latin
+// ranges starting from U+0100 and U+1E00 among others and some Cyrillic
+// characters). We use this property by defining a cXORCase mode, where the case
+// mode (always upper or lower case) is derived from the rune value. As the XOR
+// pattern for case mappings is often identical for successive runes, using
+// cXORCase can result in large series of identical trie values. This, in turn,
+// allows us to better compress the trie blocks.
+const (
+	cUncased          info = iota // 000
+	cTitle                        // 001
+	cLower                        // 010
+	cUpper                        // 011
+	cIgnorableUncased             // 100
+	cIgnorableCased               // 101 // lower case if mappings exist
+	cXORCase                      // 11x // case is cLower | ((rune&1) ^ x)
+
+	maxCaseMode = cUpper
+)
+
+func (c info) isCased() bool {
+	return c&casedMask != 0
+}
+
+func (c info) isCaseIgnorable() bool {
+	return c&ignorableMask == ignorableValue
+}
+
+func (c info) isNotCasedAndNotCaseIgnorable() bool {
+	return c&fullCasedMask == 0
+}
+
+func (c info) isCaseIgnorableAndNotCased() bool {
+	return c&fullCasedMask == cIgnorableUncased
+}
+
+func (c info) isMid() bool {
+	return c&(fullCasedMask|isMidBit) == isMidBit|cIgnorableUncased
+}
+
+// The case mapping implementation will need to know about various Canonical
+// Combining Class (CCC) values. We encode two of these in the trie value:
+// cccZero (0) and cccAbove (230). If the value is cccOther, it means that
+// CCC(r) > 0, but not 230. A value of cccBreak means that CCC(r) == 0 and that
+// the rune also has the break category Break (see below).
+const (
+	cccBreak info = iota << 4
+	cccZero
+	cccAbove
+	cccOther
+
+	cccMask = cccBreak | cccZero | cccAbove | cccOther
+)
+
+const (
+	starter       = 0
+	above         = 230
+	iotaSubscript = 240
+)
+
+// The exceptions slice holds data that does not fit in a normal info entry.
+// The entry is pointed to by the exception index in an entry. It has the
+// following format:
+//
+// Header:
+//
+//	byte 0:
+//	 7..6  unused
+//	 5..4  CCC type (same bits as entry)
+//	    3  unused
+//	 2..0  length of fold
+//
+//	byte 1:
+//	  7..6  unused
+//	  5..3  length of 1st mapping of case type
+//	  2..0  length of 2nd mapping of case type
+//
+//	  case     1st    2nd
+//	  lower -> upper, title
+//	  upper -> lower, title
+//	  title -> lower, upper
+//
+// Lengths with the value 0x7 indicate no value and implies no change.
+// A length of 0 indicates a mapping to zero-length string.
+//
+// Body bytes:
+//
+//	case folding bytes
+//	lowercase mapping bytes
+//	uppercase mapping bytes
+//	titlecase mapping bytes
+//	closure mapping bytes (for NFKC_Casefold). (TODO)
+//
+// Fallbacks:
+//
+//	missing fold  -> lower
+//	missing title -> upper
+//	all missing   -> original rune
+//
+// exceptions starts with a dummy byte to enforce that there is no zero index
+// value.
+const (
+	lengthMask = 0x07
+	lengthBits = 3
+	noChange   = 0
+)
+
+// References to generated trie.
+
+var trie = newCaseTrie(0)
+
+var sparse = sparseBlocks{
+	values:  sparseValues[:],
+	offsets: sparseOffsets[:],
+}
+
+// Sparse block lookup code.
+
+// valueRange is an entry in a sparse block.
+type valueRange struct {
+	value  uint16
+	lo, hi byte
+}
+
+type sparseBlocks struct {
+	values  []valueRange
+	offsets []uint16
+}
+
+// lookup returns the value from values block n for byte b using binary search.
+func (s *sparseBlocks) lookup(n uint32, b byte) uint16 {
+	lo := s.offsets[n]
+	hi := s.offsets[n+1]
+	for lo < hi {
+		m := lo + (hi-lo)/2
+		r := s.values[m]
+		if r.lo <= b && b <= r.hi {
+			return r.value
+		}
+		if b < r.lo {
+			hi = m
+		} else {
+			lo = m + 1
+		}
+	}
+	return 0
+}
+
+// lastRuneForTesting is the last rune used for testing. Everything after this
+// is boring.
+const lastRuneForTesting = rune(0x1FFFF)
diff --git a/vendor/golang.org/x/text/internal/internal.go b/vendor/golang.org/x/text/internal/internal.go
new file mode 100644
index 00000000000..3cddbbdda8c
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/internal.go
@@ -0,0 +1,49 @@
+// Copyright 2015 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 internal contains non-exported functionality that are used by
+// packages in the text repository.
+package internal // import "golang.org/x/text/internal"
+
+import (
+	"sort"
+
+	"golang.org/x/text/language"
+)
+
+// SortTags sorts tags in place.
+func SortTags(tags []language.Tag) {
+	sort.Sort(sorter(tags))
+}
+
+type sorter []language.Tag
+
+func (s sorter) Len() int {
+	return len(s)
+}
+
+func (s sorter) Swap(i, j int) {
+	s[i], s[j] = s[j], s[i]
+}
+
+func (s sorter) Less(i, j int) bool {
+	return s[i].String() < s[j].String()
+}
+
+// UniqueTags sorts and filters duplicate tags in place and returns a slice with
+// only unique tags.
+func UniqueTags(tags []language.Tag) []language.Tag {
+	if len(tags) <= 1 {
+		return tags
+	}
+	SortTags(tags)
+	k := 0
+	for i := 1; i < len(tags); i++ {
+		if tags[k].String() < tags[i].String() {
+			k++
+			tags[k] = tags[i]
+		}
+	}
+	return tags[:k+1]
+}
diff --git a/vendor/golang.org/x/text/internal/language/common.go b/vendor/golang.org/x/text/internal/language/common.go
new file mode 100644
index 00000000000..cdfdb749718
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/common.go
@@ -0,0 +1,16 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+package language
+
+// This file contains code common to the maketables.go and the package code.
+
+// AliasType is the type of an alias in AliasMap.
+type AliasType int8
+
+const (
+	Deprecated AliasType = iota
+	Macro
+	Legacy
+
+	AliasTypeUnknown AliasType = -1
+)
diff --git a/vendor/golang.org/x/text/internal/language/compact.go b/vendor/golang.org/x/text/internal/language/compact.go
new file mode 100644
index 00000000000..46a0015074f
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/compact.go
@@ -0,0 +1,29 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package language
+
+// CompactCoreInfo is a compact integer with the three core tags encoded.
+type CompactCoreInfo uint32
+
+// GetCompactCore generates a uint32 value that is guaranteed to be unique for
+// different language, region, and script values.
+func GetCompactCore(t Tag) (cci CompactCoreInfo, ok bool) {
+	if t.LangID > langNoIndexOffset {
+		return 0, false
+	}
+	cci |= CompactCoreInfo(t.LangID) << (8 + 12)
+	cci |= CompactCoreInfo(t.ScriptID) << 12
+	cci |= CompactCoreInfo(t.RegionID)
+	return cci, true
+}
+
+// Tag generates a tag from c.
+func (c CompactCoreInfo) Tag() Tag {
+	return Tag{
+		LangID:   Language(c >> 20),
+		RegionID: Region(c & 0x3ff),
+		ScriptID: Script(c>>12) & 0xff,
+	}
+}
diff --git a/vendor/golang.org/x/text/internal/language/compact/compact.go b/vendor/golang.org/x/text/internal/language/compact/compact.go
new file mode 100644
index 00000000000..1b36935ef7b
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/compact/compact.go
@@ -0,0 +1,61 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package compact defines a compact representation of language tags.
+//
+// Common language tags (at least all for which locale information is defined
+// in CLDR) are assigned a unique index. Each Tag is associated with such an
+// ID for selecting language-related resources (such as translations) as well
+// as one for selecting regional defaults (currency, number formatting, etc.)
+//
+// It may want to export this functionality at some point, but at this point
+// this is only available for use within x/text.
+package compact // import "golang.org/x/text/internal/language/compact"
+
+import (
+	"sort"
+	"strings"
+
+	"golang.org/x/text/internal/language"
+)
+
+// ID is an integer identifying a single tag.
+type ID uint16
+
+func getCoreIndex(t language.Tag) (id ID, ok bool) {
+	cci, ok := language.GetCompactCore(t)
+	if !ok {
+		return 0, false
+	}
+	i := sort.Search(len(coreTags), func(i int) bool {
+		return cci <= coreTags[i]
+	})
+	if i == len(coreTags) || coreTags[i] != cci {
+		return 0, false
+	}
+	return ID(i), true
+}
+
+// Parent returns the ID of the parent or the root ID if id is already the root.
+func (id ID) Parent() ID {
+	return parents[id]
+}
+
+// Tag converts id to an internal language Tag.
+func (id ID) Tag() language.Tag {
+	if int(id) >= len(coreTags) {
+		return specialTags[int(id)-len(coreTags)]
+	}
+	return coreTags[id].Tag()
+}
+
+var specialTags []language.Tag
+
+func init() {
+	tags := strings.Split(specialTagsStr, " ")
+	specialTags = make([]language.Tag, len(tags))
+	for i, t := range tags {
+		specialTags[i] = language.MustParse(t)
+	}
+}
diff --git a/vendor/golang.org/x/text/internal/language/compact/language.go b/vendor/golang.org/x/text/internal/language/compact/language.go
new file mode 100644
index 00000000000..8c1b6666fb8
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/compact/language.go
@@ -0,0 +1,260 @@
+// 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.
+
+//go:generate go run gen.go gen_index.go -output tables.go
+//go:generate go run gen_parents.go
+
+package compact
+
+// TODO: Remove above NOTE after:
+// - verifying that tables are dropped correctly (most notably matcher tables).
+
+import (
+	"strings"
+
+	"golang.org/x/text/internal/language"
+)
+
+// Tag represents a BCP 47 language tag. It is used to specify an instance of a
+// specific language or locale. All language tag values are guaranteed to be
+// well-formed.
+type Tag struct {
+	// NOTE: exported tags will become part of the public API.
+	language ID
+	locale   ID
+	full     fullTag // always a language.Tag for now.
+}
+
+const _und = 0
+
+type fullTag interface {
+	IsRoot() bool
+	Parent() language.Tag
+}
+
+// Make a compact Tag from a fully specified internal language Tag.
+func Make(t language.Tag) (tag Tag) {
+	if region := t.TypeForKey("rg"); len(region) == 6 && region[2:] == "zzzz" {
+		if r, err := language.ParseRegion(region[:2]); err == nil {
+			tFull := t
+			t, _ = t.SetTypeForKey("rg", "")
+			// TODO: should we not consider "va" for the language tag?
+			var exact1, exact2 bool
+			tag.language, exact1 = FromTag(t)
+			t.RegionID = r
+			tag.locale, exact2 = FromTag(t)
+			if !exact1 || !exact2 {
+				tag.full = tFull
+			}
+			return tag
+		}
+	}
+	lang, ok := FromTag(t)
+	tag.language = lang
+	tag.locale = lang
+	if !ok {
+		tag.full = t
+	}
+	return tag
+}
+
+// Tag returns an internal language Tag version of this tag.
+func (t Tag) Tag() language.Tag {
+	if t.full != nil {
+		return t.full.(language.Tag)
+	}
+	tag := t.language.Tag()
+	if t.language != t.locale {
+		loc := t.locale.Tag()
+		tag, _ = tag.SetTypeForKey("rg", strings.ToLower(loc.RegionID.String())+"zzzz")
+	}
+	return tag
+}
+
+// IsCompact reports whether this tag is fully defined in terms of ID.
+func (t *Tag) IsCompact() bool {
+	return t.full == nil
+}
+
+// MayHaveVariants reports whether a tag may have variants. If it returns false
+// it is guaranteed the tag does not have variants.
+func (t Tag) MayHaveVariants() bool {
+	return t.full != nil || int(t.language) >= len(coreTags)
+}
+
+// MayHaveExtensions reports whether a tag may have extensions. If it returns
+// false it is guaranteed the tag does not have them.
+func (t Tag) MayHaveExtensions() bool {
+	return t.full != nil ||
+		int(t.language) >= len(coreTags) ||
+		t.language != t.locale
+}
+
+// IsRoot returns true if t is equal to language "und".
+func (t Tag) IsRoot() bool {
+	if t.full != nil {
+		return t.full.IsRoot()
+	}
+	return t.language == _und
+}
+
+// Parent returns the CLDR parent of t. In CLDR, missing fields in data for a
+// specific language are substituted with fields from the parent language.
+// The parent for a language may change for newer versions of CLDR.
+func (t Tag) Parent() Tag {
+	if t.full != nil {
+		return Make(t.full.Parent())
+	}
+	if t.language != t.locale {
+		// Simulate stripping -u-rg-xxxxxx
+		return Tag{language: t.language, locale: t.language}
+	}
+	// TODO: use parent lookup table once cycle from internal package is
+	// removed. Probably by internalizing the table and declaring this fast
+	// enough.
+	// lang := compactID(internal.Parent(uint16(t.language)))
+	lang, _ := FromTag(t.language.Tag().Parent())
+	return Tag{language: lang, locale: lang}
+}
+
+// nextToken returns token t and the rest of the string.
+func nextToken(s string) (t, tail string) {
+	p := strings.Index(s[1:], "-")
+	if p == -1 {
+		return s[1:], ""
+	}
+	p++
+	return s[1:p], s[p:]
+}
+
+// LanguageID returns an index, where 0 <= index < NumCompactTags, for tags
+// for which data exists in the text repository.The index will change over time
+// and should not be stored in persistent storage. If t does not match a compact
+// index, exact will be false and the compact index will be returned for the
+// first match after repeatedly taking the Parent of t.
+func LanguageID(t Tag) (id ID, exact bool) {
+	return t.language, t.full == nil
+}
+
+// RegionalID returns the ID for the regional variant of this tag. This index is
+// used to indicate region-specific overrides, such as default currency, default
+// calendar and week data, default time cycle, and default measurement system
+// and unit preferences.
+//
+// For instance, the tag en-GB-u-rg-uszzzz specifies British English with US
+// settings for currency, number formatting, etc. The CompactIndex for this tag
+// will be that for en-GB, while the RegionalID will be the one corresponding to
+// en-US.
+func RegionalID(t Tag) (id ID, exact bool) {
+	return t.locale, t.full == nil
+}
+
+// LanguageTag returns t stripped of regional variant indicators.
+//
+// At the moment this means it is stripped of a regional and variant subtag "rg"
+// and "va" in the "u" extension.
+func (t Tag) LanguageTag() Tag {
+	if t.full == nil {
+		return Tag{language: t.language, locale: t.language}
+	}
+	tt := t.Tag()
+	tt.SetTypeForKey("rg", "")
+	tt.SetTypeForKey("va", "")
+	return Make(tt)
+}
+
+// RegionalTag returns the regional variant of the tag.
+//
+// At the moment this means that the region is set from the regional subtag
+// "rg" in the "u" extension.
+func (t Tag) RegionalTag() Tag {
+	rt := Tag{language: t.locale, locale: t.locale}
+	if t.full == nil {
+		return rt
+	}
+	b := language.Builder{}
+	tag := t.Tag()
+	// tag, _ = tag.SetTypeForKey("rg", "")
+	b.SetTag(t.locale.Tag())
+	if v := tag.Variants(); v != "" {
+		for _, v := range strings.Split(v, "-") {
+			b.AddVariant(v)
+		}
+	}
+	for _, e := range tag.Extensions() {
+		b.AddExt(e)
+	}
+	return t
+}
+
+// FromTag reports closest matching ID for an internal language Tag.
+func FromTag(t language.Tag) (id ID, exact bool) {
+	// TODO: perhaps give more frequent tags a lower index.
+	// TODO: we could make the indexes stable. This will excluded some
+	//       possibilities for optimization, so don't do this quite yet.
+	exact = true
+
+	b, s, r := t.Raw()
+	if t.HasString() {
+		if t.IsPrivateUse() {
+			// We have no entries for user-defined tags.
+			return 0, false
+		}
+		hasExtra := false
+		if t.HasVariants() {
+			if t.HasExtensions() {
+				build := language.Builder{}
+				build.SetTag(language.Tag{LangID: b, ScriptID: s, RegionID: r})
+				build.AddVariant(t.Variants())
+				exact = false
+				t = build.Make()
+			}
+			hasExtra = true
+		} else if _, ok := t.Extension('u'); ok {
+			// TODO: va may mean something else. Consider not considering it.
+			// Strip all but the 'va' entry.
+			old := t
+			variant := t.TypeForKey("va")
+			t = language.Tag{LangID: b, ScriptID: s, RegionID: r}
+			if variant != "" {
+				t, _ = t.SetTypeForKey("va", variant)
+				hasExtra = true
+			}
+			exact = old == t
+		} else {
+			exact = false
+		}
+		if hasExtra {
+			// We have some variants.
+			for i, s := range specialTags {
+				if s == t {
+					return ID(i + len(coreTags)), exact
+				}
+			}
+			exact = false
+		}
+	}
+	if x, ok := getCoreIndex(t); ok {
+		return x, exact
+	}
+	exact = false
+	if r != 0 && s == 0 {
+		// Deal with cases where an extra script is inserted for the region.
+		t, _ := t.Maximize()
+		if x, ok := getCoreIndex(t); ok {
+			return x, exact
+		}
+	}
+	for t = t.Parent(); t != root; t = t.Parent() {
+		// No variants specified: just compare core components.
+		// The key has the form lllssrrr, where l, s, and r are nibbles for
+		// respectively the langID, scriptID, and regionID.
+		if x, ok := getCoreIndex(t); ok {
+			return x, exact
+		}
+	}
+	return 0, exact
+}
+
+var root = language.Tag{}
diff --git a/vendor/golang.org/x/text/internal/language/compact/parents.go b/vendor/golang.org/x/text/internal/language/compact/parents.go
new file mode 100644
index 00000000000..8d810723c75
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/compact/parents.go
@@ -0,0 +1,120 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+package compact
+
+// parents maps a compact index of a tag to the compact index of the parent of
+// this tag.
+var parents = []ID{ // 775 elements
+	// Entry 0 - 3F
+	0x0000, 0x0000, 0x0001, 0x0001, 0x0000, 0x0004, 0x0000, 0x0006,
+	0x0000, 0x0008, 0x0000, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a,
+	0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a,
+	0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a,
+	0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x000a, 0x0000,
+	0x0000, 0x0028, 0x0000, 0x002a, 0x0000, 0x002c, 0x0000, 0x0000,
+	0x002f, 0x002e, 0x002e, 0x0000, 0x0033, 0x0000, 0x0035, 0x0000,
+	0x0037, 0x0000, 0x0039, 0x0000, 0x003b, 0x0000, 0x0000, 0x003e,
+	// Entry 40 - 7F
+	0x0000, 0x0040, 0x0040, 0x0000, 0x0043, 0x0043, 0x0000, 0x0046,
+	0x0000, 0x0048, 0x0000, 0x0000, 0x004b, 0x004a, 0x004a, 0x0000,
+	0x004f, 0x004f, 0x004f, 0x004f, 0x0000, 0x0054, 0x0054, 0x0000,
+	0x0057, 0x0000, 0x0059, 0x0000, 0x005b, 0x0000, 0x005d, 0x005d,
+	0x0000, 0x0060, 0x0000, 0x0062, 0x0000, 0x0064, 0x0000, 0x0066,
+	0x0066, 0x0000, 0x0069, 0x0000, 0x006b, 0x006b, 0x006b, 0x006b,
+	0x006b, 0x006b, 0x006b, 0x0000, 0x0073, 0x0000, 0x0075, 0x0000,
+	0x0077, 0x0000, 0x0000, 0x007a, 0x0000, 0x007c, 0x0000, 0x007e,
+	// Entry 80 - BF
+	0x0000, 0x0080, 0x0080, 0x0000, 0x0083, 0x0083, 0x0000, 0x0086,
+	0x0087, 0x0087, 0x0087, 0x0086, 0x0088, 0x0087, 0x0087, 0x0087,
+	0x0086, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0088,
+	0x0087, 0x0087, 0x0087, 0x0087, 0x0088, 0x0087, 0x0088, 0x0087,
+	0x0087, 0x0088, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087,
+	0x0087, 0x0087, 0x0087, 0x0086, 0x0087, 0x0087, 0x0087, 0x0087,
+	0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087,
+	0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0086, 0x0087, 0x0086,
+	// Entry C0 - FF
+	0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087,
+	0x0088, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087,
+	0x0086, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0088, 0x0087,
+	0x0087, 0x0088, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087,
+	0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0086, 0x0086, 0x0087,
+	0x0087, 0x0086, 0x0087, 0x0087, 0x0087, 0x0087, 0x0087, 0x0000,
+	0x00ef, 0x0000, 0x00f1, 0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x00f2,
+	0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x00f1, 0x00f2, 0x00f1, 0x00f1,
+	// Entry 100 - 13F
+	0x00f2, 0x00f2, 0x00f1, 0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x00f1,
+	0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x00f2, 0x0000, 0x010e,
+	0x0000, 0x0110, 0x0000, 0x0112, 0x0000, 0x0114, 0x0114, 0x0000,
+	0x0117, 0x0117, 0x0117, 0x0117, 0x0000, 0x011c, 0x0000, 0x011e,
+	0x0000, 0x0120, 0x0120, 0x0000, 0x0123, 0x0123, 0x0123, 0x0123,
+	0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123,
+	0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123,
+	0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123,
+	// Entry 140 - 17F
+	0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123,
+	0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123, 0x0123,
+	0x0123, 0x0123, 0x0000, 0x0152, 0x0000, 0x0154, 0x0000, 0x0156,
+	0x0000, 0x0158, 0x0000, 0x015a, 0x0000, 0x015c, 0x015c, 0x015c,
+	0x0000, 0x0160, 0x0000, 0x0000, 0x0163, 0x0000, 0x0165, 0x0000,
+	0x0167, 0x0167, 0x0167, 0x0000, 0x016b, 0x0000, 0x016d, 0x0000,
+	0x016f, 0x0000, 0x0171, 0x0171, 0x0000, 0x0174, 0x0000, 0x0176,
+	0x0000, 0x0178, 0x0000, 0x017a, 0x0000, 0x017c, 0x0000, 0x017e,
+	// Entry 180 - 1BF
+	0x0000, 0x0000, 0x0000, 0x0182, 0x0000, 0x0184, 0x0184, 0x0184,
+	0x0184, 0x0000, 0x0000, 0x0000, 0x018b, 0x0000, 0x0000, 0x018e,
+	0x0000, 0x0000, 0x0191, 0x0000, 0x0000, 0x0000, 0x0195, 0x0000,
+	0x0197, 0x0000, 0x0000, 0x019a, 0x0000, 0x0000, 0x019d, 0x0000,
+	0x019f, 0x0000, 0x01a1, 0x0000, 0x01a3, 0x0000, 0x01a5, 0x0000,
+	0x01a7, 0x0000, 0x01a9, 0x0000, 0x01ab, 0x0000, 0x01ad, 0x0000,
+	0x01af, 0x0000, 0x01b1, 0x01b1, 0x0000, 0x01b4, 0x0000, 0x01b6,
+	0x0000, 0x01b8, 0x0000, 0x01ba, 0x0000, 0x01bc, 0x0000, 0x0000,
+	// Entry 1C0 - 1FF
+	0x01bf, 0x0000, 0x01c1, 0x0000, 0x01c3, 0x0000, 0x01c5, 0x0000,
+	0x01c7, 0x0000, 0x01c9, 0x0000, 0x01cb, 0x01cb, 0x01cb, 0x01cb,
+	0x0000, 0x01d0, 0x0000, 0x01d2, 0x01d2, 0x0000, 0x01d5, 0x0000,
+	0x01d7, 0x0000, 0x01d9, 0x0000, 0x01db, 0x0000, 0x01dd, 0x0000,
+	0x01df, 0x01df, 0x0000, 0x01e2, 0x0000, 0x01e4, 0x0000, 0x01e6,
+	0x0000, 0x01e8, 0x0000, 0x01ea, 0x0000, 0x01ec, 0x0000, 0x01ee,
+	0x0000, 0x01f0, 0x0000, 0x0000, 0x01f3, 0x0000, 0x01f5, 0x01f5,
+	0x01f5, 0x0000, 0x01f9, 0x0000, 0x01fb, 0x0000, 0x01fd, 0x0000,
+	// Entry 200 - 23F
+	0x01ff, 0x0000, 0x0000, 0x0202, 0x0000, 0x0204, 0x0204, 0x0000,
+	0x0207, 0x0000, 0x0209, 0x0209, 0x0000, 0x020c, 0x020c, 0x0000,
+	0x020f, 0x020f, 0x020f, 0x020f, 0x020f, 0x020f, 0x020f, 0x0000,
+	0x0217, 0x0000, 0x0219, 0x0000, 0x021b, 0x0000, 0x0000, 0x0000,
+	0x0000, 0x0000, 0x0221, 0x0000, 0x0000, 0x0224, 0x0000, 0x0226,
+	0x0226, 0x0000, 0x0229, 0x0000, 0x022b, 0x022b, 0x0000, 0x0000,
+	0x022f, 0x022e, 0x022e, 0x0000, 0x0000, 0x0234, 0x0000, 0x0236,
+	0x0000, 0x0238, 0x0000, 0x0244, 0x023a, 0x0244, 0x0244, 0x0244,
+	// Entry 240 - 27F
+	0x0244, 0x0244, 0x0244, 0x0244, 0x023a, 0x0244, 0x0244, 0x0000,
+	0x0247, 0x0247, 0x0247, 0x0000, 0x024b, 0x0000, 0x024d, 0x0000,
+	0x024f, 0x024f, 0x0000, 0x0252, 0x0000, 0x0254, 0x0254, 0x0254,
+	0x0254, 0x0254, 0x0254, 0x0000, 0x025b, 0x0000, 0x025d, 0x0000,
+	0x025f, 0x0000, 0x0261, 0x0000, 0x0263, 0x0000, 0x0265, 0x0000,
+	0x0000, 0x0268, 0x0268, 0x0268, 0x0000, 0x026c, 0x0000, 0x026e,
+	0x0000, 0x0270, 0x0000, 0x0000, 0x0000, 0x0274, 0x0273, 0x0273,
+	0x0000, 0x0278, 0x0000, 0x027a, 0x0000, 0x027c, 0x0000, 0x0000,
+	// Entry 280 - 2BF
+	0x0000, 0x0000, 0x0281, 0x0000, 0x0000, 0x0284, 0x0000, 0x0286,
+	0x0286, 0x0286, 0x0286, 0x0000, 0x028b, 0x028b, 0x028b, 0x0000,
+	0x028f, 0x028f, 0x028f, 0x028f, 0x028f, 0x0000, 0x0295, 0x0295,
+	0x0295, 0x0295, 0x0000, 0x0000, 0x0000, 0x0000, 0x029d, 0x029d,
+	0x029d, 0x0000, 0x02a1, 0x02a1, 0x02a1, 0x02a1, 0x0000, 0x0000,
+	0x02a7, 0x02a7, 0x02a7, 0x02a7, 0x0000, 0x02ac, 0x0000, 0x02ae,
+	0x02ae, 0x0000, 0x02b1, 0x0000, 0x02b3, 0x0000, 0x02b5, 0x02b5,
+	0x0000, 0x0000, 0x02b9, 0x0000, 0x0000, 0x0000, 0x02bd, 0x0000,
+	// Entry 2C0 - 2FF
+	0x02bf, 0x02bf, 0x0000, 0x0000, 0x02c3, 0x0000, 0x02c5, 0x0000,
+	0x02c7, 0x0000, 0x02c9, 0x0000, 0x02cb, 0x0000, 0x02cd, 0x02cd,
+	0x0000, 0x0000, 0x02d1, 0x0000, 0x02d3, 0x02d0, 0x02d0, 0x0000,
+	0x0000, 0x02d8, 0x02d7, 0x02d7, 0x0000, 0x0000, 0x02dd, 0x0000,
+	0x02df, 0x0000, 0x02e1, 0x0000, 0x0000, 0x02e4, 0x0000, 0x02e6,
+	0x0000, 0x0000, 0x02e9, 0x0000, 0x02eb, 0x0000, 0x02ed, 0x0000,
+	0x02ef, 0x02ef, 0x0000, 0x0000, 0x02f3, 0x02f2, 0x02f2, 0x0000,
+	0x02f7, 0x0000, 0x02f9, 0x02f9, 0x02f9, 0x02f9, 0x02f9, 0x0000,
+	// Entry 300 - 33F
+	0x02ff, 0x0300, 0x02ff, 0x0000, 0x0303, 0x0051, 0x00e6,
+} // Size: 1574 bytes
+
+// Total table size 1574 bytes (1KiB); checksum: 895AAF0B
diff --git a/vendor/golang.org/x/text/internal/language/compact/tables.go b/vendor/golang.org/x/text/internal/language/compact/tables.go
new file mode 100644
index 00000000000..a09ed198a5d
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/compact/tables.go
@@ -0,0 +1,1015 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+package compact
+
+import "golang.org/x/text/internal/language"
+
+// CLDRVersion is the CLDR version from which the tables in this package are derived.
+const CLDRVersion = "32"
+
+// NumCompactTags is the number of common tags. The maximum tag is
+// NumCompactTags-1.
+const NumCompactTags = 775
+const (
+	undIndex          ID = 0
+	afIndex           ID = 1
+	afNAIndex         ID = 2
+	afZAIndex         ID = 3
+	agqIndex          ID = 4
+	agqCMIndex        ID = 5
+	akIndex           ID = 6
+	akGHIndex         ID = 7
+	amIndex           ID = 8
+	amETIndex         ID = 9
+	arIndex           ID = 10
+	ar001Index        ID = 11
+	arAEIndex         ID = 12
+	arBHIndex         ID = 13
+	arDJIndex         ID = 14
+	arDZIndex         ID = 15
+	arEGIndex         ID = 16
+	arEHIndex         ID = 17
+	arERIndex         ID = 18
+	arILIndex         ID = 19
+	arIQIndex         ID = 20
+	arJOIndex         ID = 21
+	arKMIndex         ID = 22
+	arKWIndex         ID = 23
+	arLBIndex         ID = 24
+	arLYIndex         ID = 25
+	arMAIndex         ID = 26
+	arMRIndex         ID = 27
+	arOMIndex         ID = 28
+	arPSIndex         ID = 29
+	arQAIndex         ID = 30
+	arSAIndex         ID = 31
+	arSDIndex         ID = 32
+	arSOIndex         ID = 33
+	arSSIndex         ID = 34
+	arSYIndex         ID = 35
+	arTDIndex         ID = 36
+	arTNIndex         ID = 37
+	arYEIndex         ID = 38
+	arsIndex          ID = 39
+	asIndex           ID = 40
+	asINIndex         ID = 41
+	asaIndex          ID = 42
+	asaTZIndex        ID = 43
+	astIndex          ID = 44
+	astESIndex        ID = 45
+	azIndex           ID = 46
+	azCyrlIndex       ID = 47
+	azCyrlAZIndex     ID = 48
+	azLatnIndex       ID = 49
+	azLatnAZIndex     ID = 50
+	basIndex          ID = 51
+	basCMIndex        ID = 52
+	beIndex           ID = 53
+	beBYIndex         ID = 54
+	bemIndex          ID = 55
+	bemZMIndex        ID = 56
+	bezIndex          ID = 57
+	bezTZIndex        ID = 58
+	bgIndex           ID = 59
+	bgBGIndex         ID = 60
+	bhIndex           ID = 61
+	bmIndex           ID = 62
+	bmMLIndex         ID = 63
+	bnIndex           ID = 64
+	bnBDIndex         ID = 65
+	bnINIndex         ID = 66
+	boIndex           ID = 67
+	boCNIndex         ID = 68
+	boINIndex         ID = 69
+	brIndex           ID = 70
+	brFRIndex         ID = 71
+	brxIndex          ID = 72
+	brxINIndex        ID = 73
+	bsIndex           ID = 74
+	bsCyrlIndex       ID = 75
+	bsCyrlBAIndex     ID = 76
+	bsLatnIndex       ID = 77
+	bsLatnBAIndex     ID = 78
+	caIndex           ID = 79
+	caADIndex         ID = 80
+	caESIndex         ID = 81
+	caFRIndex         ID = 82
+	caITIndex         ID = 83
+	ccpIndex          ID = 84
+	ccpBDIndex        ID = 85
+	ccpINIndex        ID = 86
+	ceIndex           ID = 87
+	ceRUIndex         ID = 88
+	cggIndex          ID = 89
+	cggUGIndex        ID = 90
+	chrIndex          ID = 91
+	chrUSIndex        ID = 92
+	ckbIndex          ID = 93
+	ckbIQIndex        ID = 94
+	ckbIRIndex        ID = 95
+	csIndex           ID = 96
+	csCZIndex         ID = 97
+	cuIndex           ID = 98
+	cuRUIndex         ID = 99
+	cyIndex           ID = 100
+	cyGBIndex         ID = 101
+	daIndex           ID = 102
+	daDKIndex         ID = 103
+	daGLIndex         ID = 104
+	davIndex          ID = 105
+	davKEIndex        ID = 106
+	deIndex           ID = 107
+	deATIndex         ID = 108
+	deBEIndex         ID = 109
+	deCHIndex         ID = 110
+	deDEIndex         ID = 111
+	deITIndex         ID = 112
+	deLIIndex         ID = 113
+	deLUIndex         ID = 114
+	djeIndex          ID = 115
+	djeNEIndex        ID = 116
+	dsbIndex          ID = 117
+	dsbDEIndex        ID = 118
+	duaIndex          ID = 119
+	duaCMIndex        ID = 120
+	dvIndex           ID = 121
+	dyoIndex          ID = 122
+	dyoSNIndex        ID = 123
+	dzIndex           ID = 124
+	dzBTIndex         ID = 125
+	ebuIndex          ID = 126
+	ebuKEIndex        ID = 127
+	eeIndex           ID = 128
+	eeGHIndex         ID = 129
+	eeTGIndex         ID = 130
+	elIndex           ID = 131
+	elCYIndex         ID = 132
+	elGRIndex         ID = 133
+	enIndex           ID = 134
+	en001Index        ID = 135
+	en150Index        ID = 136
+	enAGIndex         ID = 137
+	enAIIndex         ID = 138
+	enASIndex         ID = 139
+	enATIndex         ID = 140
+	enAUIndex         ID = 141
+	enBBIndex         ID = 142
+	enBEIndex         ID = 143
+	enBIIndex         ID = 144
+	enBMIndex         ID = 145
+	enBSIndex         ID = 146
+	enBWIndex         ID = 147
+	enBZIndex         ID = 148
+	enCAIndex         ID = 149
+	enCCIndex         ID = 150
+	enCHIndex         ID = 151
+	enCKIndex         ID = 152
+	enCMIndex         ID = 153
+	enCXIndex         ID = 154
+	enCYIndex         ID = 155
+	enDEIndex         ID = 156
+	enDGIndex         ID = 157
+	enDKIndex         ID = 158
+	enDMIndex         ID = 159
+	enERIndex         ID = 160
+	enFIIndex         ID = 161
+	enFJIndex         ID = 162
+	enFKIndex         ID = 163
+	enFMIndex         ID = 164
+	enGBIndex         ID = 165
+	enGDIndex         ID = 166
+	enGGIndex         ID = 167
+	enGHIndex         ID = 168
+	enGIIndex         ID = 169
+	enGMIndex         ID = 170
+	enGUIndex         ID = 171
+	enGYIndex         ID = 172
+	enHKIndex         ID = 173
+	enIEIndex         ID = 174
+	enILIndex         ID = 175
+	enIMIndex         ID = 176
+	enINIndex         ID = 177
+	enIOIndex         ID = 178
+	enJEIndex         ID = 179
+	enJMIndex         ID = 180
+	enKEIndex         ID = 181
+	enKIIndex         ID = 182
+	enKNIndex         ID = 183
+	enKYIndex         ID = 184
+	enLCIndex         ID = 185
+	enLRIndex         ID = 186
+	enLSIndex         ID = 187
+	enMGIndex         ID = 188
+	enMHIndex         ID = 189
+	enMOIndex         ID = 190
+	enMPIndex         ID = 191
+	enMSIndex         ID = 192
+	enMTIndex         ID = 193
+	enMUIndex         ID = 194
+	enMWIndex         ID = 195
+	enMYIndex         ID = 196
+	enNAIndex         ID = 197
+	enNFIndex         ID = 198
+	enNGIndex         ID = 199
+	enNLIndex         ID = 200
+	enNRIndex         ID = 201
+	enNUIndex         ID = 202
+	enNZIndex         ID = 203
+	enPGIndex         ID = 204
+	enPHIndex         ID = 205
+	enPKIndex         ID = 206
+	enPNIndex         ID = 207
+	enPRIndex         ID = 208
+	enPWIndex         ID = 209
+	enRWIndex         ID = 210
+	enSBIndex         ID = 211
+	enSCIndex         ID = 212
+	enSDIndex         ID = 213
+	enSEIndex         ID = 214
+	enSGIndex         ID = 215
+	enSHIndex         ID = 216
+	enSIIndex         ID = 217
+	enSLIndex         ID = 218
+	enSSIndex         ID = 219
+	enSXIndex         ID = 220
+	enSZIndex         ID = 221
+	enTCIndex         ID = 222
+	enTKIndex         ID = 223
+	enTOIndex         ID = 224
+	enTTIndex         ID = 225
+	enTVIndex         ID = 226
+	enTZIndex         ID = 227
+	enUGIndex         ID = 228
+	enUMIndex         ID = 229
+	enUSIndex         ID = 230
+	enVCIndex         ID = 231
+	enVGIndex         ID = 232
+	enVIIndex         ID = 233
+	enVUIndex         ID = 234
+	enWSIndex         ID = 235
+	enZAIndex         ID = 236
+	enZMIndex         ID = 237
+	enZWIndex         ID = 238
+	eoIndex           ID = 239
+	eo001Index        ID = 240
+	esIndex           ID = 241
+	es419Index        ID = 242
+	esARIndex         ID = 243
+	esBOIndex         ID = 244
+	esBRIndex         ID = 245
+	esBZIndex         ID = 246
+	esCLIndex         ID = 247
+	esCOIndex         ID = 248
+	esCRIndex         ID = 249
+	esCUIndex         ID = 250
+	esDOIndex         ID = 251
+	esEAIndex         ID = 252
+	esECIndex         ID = 253
+	esESIndex         ID = 254
+	esGQIndex         ID = 255
+	esGTIndex         ID = 256
+	esHNIndex         ID = 257
+	esICIndex         ID = 258
+	esMXIndex         ID = 259
+	esNIIndex         ID = 260
+	esPAIndex         ID = 261
+	esPEIndex         ID = 262
+	esPHIndex         ID = 263
+	esPRIndex         ID = 264
+	esPYIndex         ID = 265
+	esSVIndex         ID = 266
+	esUSIndex         ID = 267
+	esUYIndex         ID = 268
+	esVEIndex         ID = 269
+	etIndex           ID = 270
+	etEEIndex         ID = 271
+	euIndex           ID = 272
+	euESIndex         ID = 273
+	ewoIndex          ID = 274
+	ewoCMIndex        ID = 275
+	faIndex           ID = 276
+	faAFIndex         ID = 277
+	faIRIndex         ID = 278
+	ffIndex           ID = 279
+	ffCMIndex         ID = 280
+	ffGNIndex         ID = 281
+	ffMRIndex         ID = 282
+	ffSNIndex         ID = 283
+	fiIndex           ID = 284
+	fiFIIndex         ID = 285
+	filIndex          ID = 286
+	filPHIndex        ID = 287
+	foIndex           ID = 288
+	foDKIndex         ID = 289
+	foFOIndex         ID = 290
+	frIndex           ID = 291
+	frBEIndex         ID = 292
+	frBFIndex         ID = 293
+	frBIIndex         ID = 294
+	frBJIndex         ID = 295
+	frBLIndex         ID = 296
+	frCAIndex         ID = 297
+	frCDIndex         ID = 298
+	frCFIndex         ID = 299
+	frCGIndex         ID = 300
+	frCHIndex         ID = 301
+	frCIIndex         ID = 302
+	frCMIndex         ID = 303
+	frDJIndex         ID = 304
+	frDZIndex         ID = 305
+	frFRIndex         ID = 306
+	frGAIndex         ID = 307
+	frGFIndex         ID = 308
+	frGNIndex         ID = 309
+	frGPIndex         ID = 310
+	frGQIndex         ID = 311
+	frHTIndex         ID = 312
+	frKMIndex         ID = 313
+	frLUIndex         ID = 314
+	frMAIndex         ID = 315
+	frMCIndex         ID = 316
+	frMFIndex         ID = 317
+	frMGIndex         ID = 318
+	frMLIndex         ID = 319
+	frMQIndex         ID = 320
+	frMRIndex         ID = 321
+	frMUIndex         ID = 322
+	frNCIndex         ID = 323
+	frNEIndex         ID = 324
+	frPFIndex         ID = 325
+	frPMIndex         ID = 326
+	frREIndex         ID = 327
+	frRWIndex         ID = 328
+	frSCIndex         ID = 329
+	frSNIndex         ID = 330
+	frSYIndex         ID = 331
+	frTDIndex         ID = 332
+	frTGIndex         ID = 333
+	frTNIndex         ID = 334
+	frVUIndex         ID = 335
+	frWFIndex         ID = 336
+	frYTIndex         ID = 337
+	furIndex          ID = 338
+	furITIndex        ID = 339
+	fyIndex           ID = 340
+	fyNLIndex         ID = 341
+	gaIndex           ID = 342
+	gaIEIndex         ID = 343
+	gdIndex           ID = 344
+	gdGBIndex         ID = 345
+	glIndex           ID = 346
+	glESIndex         ID = 347
+	gswIndex          ID = 348
+	gswCHIndex        ID = 349
+	gswFRIndex        ID = 350
+	gswLIIndex        ID = 351
+	guIndex           ID = 352
+	guINIndex         ID = 353
+	guwIndex          ID = 354
+	guzIndex          ID = 355
+	guzKEIndex        ID = 356
+	gvIndex           ID = 357
+	gvIMIndex         ID = 358
+	haIndex           ID = 359
+	haGHIndex         ID = 360
+	haNEIndex         ID = 361
+	haNGIndex         ID = 362
+	hawIndex          ID = 363
+	hawUSIndex        ID = 364
+	heIndex           ID = 365
+	heILIndex         ID = 366
+	hiIndex           ID = 367
+	hiINIndex         ID = 368
+	hrIndex           ID = 369
+	hrBAIndex         ID = 370
+	hrHRIndex         ID = 371
+	hsbIndex          ID = 372
+	hsbDEIndex        ID = 373
+	huIndex           ID = 374
+	huHUIndex         ID = 375
+	hyIndex           ID = 376
+	hyAMIndex         ID = 377
+	idIndex           ID = 378
+	idIDIndex         ID = 379
+	igIndex           ID = 380
+	igNGIndex         ID = 381
+	iiIndex           ID = 382
+	iiCNIndex         ID = 383
+	inIndex           ID = 384
+	ioIndex           ID = 385
+	isIndex           ID = 386
+	isISIndex         ID = 387
+	itIndex           ID = 388
+	itCHIndex         ID = 389
+	itITIndex         ID = 390
+	itSMIndex         ID = 391
+	itVAIndex         ID = 392
+	iuIndex           ID = 393
+	iwIndex           ID = 394
+	jaIndex           ID = 395
+	jaJPIndex         ID = 396
+	jboIndex          ID = 397
+	jgoIndex          ID = 398
+	jgoCMIndex        ID = 399
+	jiIndex           ID = 400
+	jmcIndex          ID = 401
+	jmcTZIndex        ID = 402
+	jvIndex           ID = 403
+	jwIndex           ID = 404
+	kaIndex           ID = 405
+	kaGEIndex         ID = 406
+	kabIndex          ID = 407
+	kabDZIndex        ID = 408
+	kajIndex          ID = 409
+	kamIndex          ID = 410
+	kamKEIndex        ID = 411
+	kcgIndex          ID = 412
+	kdeIndex          ID = 413
+	kdeTZIndex        ID = 414
+	keaIndex          ID = 415
+	keaCVIndex        ID = 416
+	khqIndex          ID = 417
+	khqMLIndex        ID = 418
+	kiIndex           ID = 419
+	kiKEIndex         ID = 420
+	kkIndex           ID = 421
+	kkKZIndex         ID = 422
+	kkjIndex          ID = 423
+	kkjCMIndex        ID = 424
+	klIndex           ID = 425
+	klGLIndex         ID = 426
+	klnIndex          ID = 427
+	klnKEIndex        ID = 428
+	kmIndex           ID = 429
+	kmKHIndex         ID = 430
+	knIndex           ID = 431
+	knINIndex         ID = 432
+	koIndex           ID = 433
+	koKPIndex         ID = 434
+	koKRIndex         ID = 435
+	kokIndex          ID = 436
+	kokINIndex        ID = 437
+	ksIndex           ID = 438
+	ksINIndex         ID = 439
+	ksbIndex          ID = 440
+	ksbTZIndex        ID = 441
+	ksfIndex          ID = 442
+	ksfCMIndex        ID = 443
+	kshIndex          ID = 444
+	kshDEIndex        ID = 445
+	kuIndex           ID = 446
+	kwIndex           ID = 447
+	kwGBIndex         ID = 448
+	kyIndex           ID = 449
+	kyKGIndex         ID = 450
+	lagIndex          ID = 451
+	lagTZIndex        ID = 452
+	lbIndex           ID = 453
+	lbLUIndex         ID = 454
+	lgIndex           ID = 455
+	lgUGIndex         ID = 456
+	lktIndex          ID = 457
+	lktUSIndex        ID = 458
+	lnIndex           ID = 459
+	lnAOIndex         ID = 460
+	lnCDIndex         ID = 461
+	lnCFIndex         ID = 462
+	lnCGIndex         ID = 463
+	loIndex           ID = 464
+	loLAIndex         ID = 465
+	lrcIndex          ID = 466
+	lrcIQIndex        ID = 467
+	lrcIRIndex        ID = 468
+	ltIndex           ID = 469
+	ltLTIndex         ID = 470
+	luIndex           ID = 471
+	luCDIndex         ID = 472
+	luoIndex          ID = 473
+	luoKEIndex        ID = 474
+	luyIndex          ID = 475
+	luyKEIndex        ID = 476
+	lvIndex           ID = 477
+	lvLVIndex         ID = 478
+	masIndex          ID = 479
+	masKEIndex        ID = 480
+	masTZIndex        ID = 481
+	merIndex          ID = 482
+	merKEIndex        ID = 483
+	mfeIndex          ID = 484
+	mfeMUIndex        ID = 485
+	mgIndex           ID = 486
+	mgMGIndex         ID = 487
+	mghIndex          ID = 488
+	mghMZIndex        ID = 489
+	mgoIndex          ID = 490
+	mgoCMIndex        ID = 491
+	mkIndex           ID = 492
+	mkMKIndex         ID = 493
+	mlIndex           ID = 494
+	mlINIndex         ID = 495
+	mnIndex           ID = 496
+	mnMNIndex         ID = 497
+	moIndex           ID = 498
+	mrIndex           ID = 499
+	mrINIndex         ID = 500
+	msIndex           ID = 501
+	msBNIndex         ID = 502
+	msMYIndex         ID = 503
+	msSGIndex         ID = 504
+	mtIndex           ID = 505
+	mtMTIndex         ID = 506
+	muaIndex          ID = 507
+	muaCMIndex        ID = 508
+	myIndex           ID = 509
+	myMMIndex         ID = 510
+	mznIndex          ID = 511
+	mznIRIndex        ID = 512
+	nahIndex          ID = 513
+	naqIndex          ID = 514
+	naqNAIndex        ID = 515
+	nbIndex           ID = 516
+	nbNOIndex         ID = 517
+	nbSJIndex         ID = 518
+	ndIndex           ID = 519
+	ndZWIndex         ID = 520
+	ndsIndex          ID = 521
+	ndsDEIndex        ID = 522
+	ndsNLIndex        ID = 523
+	neIndex           ID = 524
+	neINIndex         ID = 525
+	neNPIndex         ID = 526
+	nlIndex           ID = 527
+	nlAWIndex         ID = 528
+	nlBEIndex         ID = 529
+	nlBQIndex         ID = 530
+	nlCWIndex         ID = 531
+	nlNLIndex         ID = 532
+	nlSRIndex         ID = 533
+	nlSXIndex         ID = 534
+	nmgIndex          ID = 535
+	nmgCMIndex        ID = 536
+	nnIndex           ID = 537
+	nnNOIndex         ID = 538
+	nnhIndex          ID = 539
+	nnhCMIndex        ID = 540
+	noIndex           ID = 541
+	nqoIndex          ID = 542
+	nrIndex           ID = 543
+	nsoIndex          ID = 544
+	nusIndex          ID = 545
+	nusSSIndex        ID = 546
+	nyIndex           ID = 547
+	nynIndex          ID = 548
+	nynUGIndex        ID = 549
+	omIndex           ID = 550
+	omETIndex         ID = 551
+	omKEIndex         ID = 552
+	orIndex           ID = 553
+	orINIndex         ID = 554
+	osIndex           ID = 555
+	osGEIndex         ID = 556
+	osRUIndex         ID = 557
+	paIndex           ID = 558
+	paArabIndex       ID = 559
+	paArabPKIndex     ID = 560
+	paGuruIndex       ID = 561
+	paGuruINIndex     ID = 562
+	papIndex          ID = 563
+	plIndex           ID = 564
+	plPLIndex         ID = 565
+	prgIndex          ID = 566
+	prg001Index       ID = 567
+	psIndex           ID = 568
+	psAFIndex         ID = 569
+	ptIndex           ID = 570
+	ptAOIndex         ID = 571
+	ptBRIndex         ID = 572
+	ptCHIndex         ID = 573
+	ptCVIndex         ID = 574
+	ptGQIndex         ID = 575
+	ptGWIndex         ID = 576
+	ptLUIndex         ID = 577
+	ptMOIndex         ID = 578
+	ptMZIndex         ID = 579
+	ptPTIndex         ID = 580
+	ptSTIndex         ID = 581
+	ptTLIndex         ID = 582
+	quIndex           ID = 583
+	quBOIndex         ID = 584
+	quECIndex         ID = 585
+	quPEIndex         ID = 586
+	rmIndex           ID = 587
+	rmCHIndex         ID = 588
+	rnIndex           ID = 589
+	rnBIIndex         ID = 590
+	roIndex           ID = 591
+	roMDIndex         ID = 592
+	roROIndex         ID = 593
+	rofIndex          ID = 594
+	rofTZIndex        ID = 595
+	ruIndex           ID = 596
+	ruBYIndex         ID = 597
+	ruKGIndex         ID = 598
+	ruKZIndex         ID = 599
+	ruMDIndex         ID = 600
+	ruRUIndex         ID = 601
+	ruUAIndex         ID = 602
+	rwIndex           ID = 603
+	rwRWIndex         ID = 604
+	rwkIndex          ID = 605
+	rwkTZIndex        ID = 606
+	sahIndex          ID = 607
+	sahRUIndex        ID = 608
+	saqIndex          ID = 609
+	saqKEIndex        ID = 610
+	sbpIndex          ID = 611
+	sbpTZIndex        ID = 612
+	sdIndex           ID = 613
+	sdPKIndex         ID = 614
+	sdhIndex          ID = 615
+	seIndex           ID = 616
+	seFIIndex         ID = 617
+	seNOIndex         ID = 618
+	seSEIndex         ID = 619
+	sehIndex          ID = 620
+	sehMZIndex        ID = 621
+	sesIndex          ID = 622
+	sesMLIndex        ID = 623
+	sgIndex           ID = 624
+	sgCFIndex         ID = 625
+	shIndex           ID = 626
+	shiIndex          ID = 627
+	shiLatnIndex      ID = 628
+	shiLatnMAIndex    ID = 629
+	shiTfngIndex      ID = 630
+	shiTfngMAIndex    ID = 631
+	siIndex           ID = 632
+	siLKIndex         ID = 633
+	skIndex           ID = 634
+	skSKIndex         ID = 635
+	slIndex           ID = 636
+	slSIIndex         ID = 637
+	smaIndex          ID = 638
+	smiIndex          ID = 639
+	smjIndex          ID = 640
+	smnIndex          ID = 641
+	smnFIIndex        ID = 642
+	smsIndex          ID = 643
+	snIndex           ID = 644
+	snZWIndex         ID = 645
+	soIndex           ID = 646
+	soDJIndex         ID = 647
+	soETIndex         ID = 648
+	soKEIndex         ID = 649
+	soSOIndex         ID = 650
+	sqIndex           ID = 651
+	sqALIndex         ID = 652
+	sqMKIndex         ID = 653
+	sqXKIndex         ID = 654
+	srIndex           ID = 655
+	srCyrlIndex       ID = 656
+	srCyrlBAIndex     ID = 657
+	srCyrlMEIndex     ID = 658
+	srCyrlRSIndex     ID = 659
+	srCyrlXKIndex     ID = 660
+	srLatnIndex       ID = 661
+	srLatnBAIndex     ID = 662
+	srLatnMEIndex     ID = 663
+	srLatnRSIndex     ID = 664
+	srLatnXKIndex     ID = 665
+	ssIndex           ID = 666
+	ssyIndex          ID = 667
+	stIndex           ID = 668
+	svIndex           ID = 669
+	svAXIndex         ID = 670
+	svFIIndex         ID = 671
+	svSEIndex         ID = 672
+	swIndex           ID = 673
+	swCDIndex         ID = 674
+	swKEIndex         ID = 675
+	swTZIndex         ID = 676
+	swUGIndex         ID = 677
+	syrIndex          ID = 678
+	taIndex           ID = 679
+	taINIndex         ID = 680
+	taLKIndex         ID = 681
+	taMYIndex         ID = 682
+	taSGIndex         ID = 683
+	teIndex           ID = 684
+	teINIndex         ID = 685
+	teoIndex          ID = 686
+	teoKEIndex        ID = 687
+	teoUGIndex        ID = 688
+	tgIndex           ID = 689
+	tgTJIndex         ID = 690
+	thIndex           ID = 691
+	thTHIndex         ID = 692
+	tiIndex           ID = 693
+	tiERIndex         ID = 694
+	tiETIndex         ID = 695
+	tigIndex          ID = 696
+	tkIndex           ID = 697
+	tkTMIndex         ID = 698
+	tlIndex           ID = 699
+	tnIndex           ID = 700
+	toIndex           ID = 701
+	toTOIndex         ID = 702
+	trIndex           ID = 703
+	trCYIndex         ID = 704
+	trTRIndex         ID = 705
+	tsIndex           ID = 706
+	ttIndex           ID = 707
+	ttRUIndex         ID = 708
+	twqIndex          ID = 709
+	twqNEIndex        ID = 710
+	tzmIndex          ID = 711
+	tzmMAIndex        ID = 712
+	ugIndex           ID = 713
+	ugCNIndex         ID = 714
+	ukIndex           ID = 715
+	ukUAIndex         ID = 716
+	urIndex           ID = 717
+	urINIndex         ID = 718
+	urPKIndex         ID = 719
+	uzIndex           ID = 720
+	uzArabIndex       ID = 721
+	uzArabAFIndex     ID = 722
+	uzCyrlIndex       ID = 723
+	uzCyrlUZIndex     ID = 724
+	uzLatnIndex       ID = 725
+	uzLatnUZIndex     ID = 726
+	vaiIndex          ID = 727
+	vaiLatnIndex      ID = 728
+	vaiLatnLRIndex    ID = 729
+	vaiVaiiIndex      ID = 730
+	vaiVaiiLRIndex    ID = 731
+	veIndex           ID = 732
+	viIndex           ID = 733
+	viVNIndex         ID = 734
+	voIndex           ID = 735
+	vo001Index        ID = 736
+	vunIndex          ID = 737
+	vunTZIndex        ID = 738
+	waIndex           ID = 739
+	waeIndex          ID = 740
+	waeCHIndex        ID = 741
+	woIndex           ID = 742
+	woSNIndex         ID = 743
+	xhIndex           ID = 744
+	xogIndex          ID = 745
+	xogUGIndex        ID = 746
+	yavIndex          ID = 747
+	yavCMIndex        ID = 748
+	yiIndex           ID = 749
+	yi001Index        ID = 750
+	yoIndex           ID = 751
+	yoBJIndex         ID = 752
+	yoNGIndex         ID = 753
+	yueIndex          ID = 754
+	yueHansIndex      ID = 755
+	yueHansCNIndex    ID = 756
+	yueHantIndex      ID = 757
+	yueHantHKIndex    ID = 758
+	zghIndex          ID = 759
+	zghMAIndex        ID = 760
+	zhIndex           ID = 761
+	zhHansIndex       ID = 762
+	zhHansCNIndex     ID = 763
+	zhHansHKIndex     ID = 764
+	zhHansMOIndex     ID = 765
+	zhHansSGIndex     ID = 766
+	zhHantIndex       ID = 767
+	zhHantHKIndex     ID = 768
+	zhHantMOIndex     ID = 769
+	zhHantTWIndex     ID = 770
+	zuIndex           ID = 771
+	zuZAIndex         ID = 772
+	caESvalenciaIndex ID = 773
+	enUSuvaposixIndex ID = 774
+)
+
+var coreTags = []language.CompactCoreInfo{ // 773 elements
+	// Entry 0 - 1F
+	0x00000000, 0x01600000, 0x016000d3, 0x01600162,
+	0x01c00000, 0x01c00052, 0x02100000, 0x02100081,
+	0x02700000, 0x02700070, 0x03a00000, 0x03a00001,
+	0x03a00023, 0x03a00039, 0x03a00063, 0x03a00068,
+	0x03a0006c, 0x03a0006d, 0x03a0006e, 0x03a00098,
+	0x03a0009c, 0x03a000a2, 0x03a000a9, 0x03a000ad,
+	0x03a000b1, 0x03a000ba, 0x03a000bb, 0x03a000ca,
+	0x03a000e2, 0x03a000ee, 0x03a000f4, 0x03a00109,
+	// Entry 20 - 3F
+	0x03a0010c, 0x03a00116, 0x03a00118, 0x03a0011d,
+	0x03a00121, 0x03a00129, 0x03a0015f, 0x04000000,
+	0x04300000, 0x0430009a, 0x04400000, 0x04400130,
+	0x04800000, 0x0480006f, 0x05800000, 0x05820000,
+	0x05820032, 0x0585b000, 0x0585b032, 0x05e00000,
+	0x05e00052, 0x07100000, 0x07100047, 0x07500000,
+	0x07500163, 0x07900000, 0x07900130, 0x07e00000,
+	0x07e00038, 0x08200000, 0x0a000000, 0x0a0000c4,
+	// Entry 40 - 5F
+	0x0a500000, 0x0a500035, 0x0a50009a, 0x0a900000,
+	0x0a900053, 0x0a90009a, 0x0b200000, 0x0b200079,
+	0x0b500000, 0x0b50009a, 0x0b700000, 0x0b720000,
+	0x0b720033, 0x0b75b000, 0x0b75b033, 0x0d700000,
+	0x0d700022, 0x0d70006f, 0x0d700079, 0x0d70009f,
+	0x0db00000, 0x0db00035, 0x0db0009a, 0x0dc00000,
+	0x0dc00107, 0x0df00000, 0x0df00132, 0x0e500000,
+	0x0e500136, 0x0e900000, 0x0e90009c, 0x0e90009d,
+	// Entry 60 - 7F
+	0x0fa00000, 0x0fa0005f, 0x0fe00000, 0x0fe00107,
+	0x10000000, 0x1000007c, 0x10100000, 0x10100064,
+	0x10100083, 0x10800000, 0x108000a5, 0x10d00000,
+	0x10d0002e, 0x10d00036, 0x10d0004e, 0x10d00061,
+	0x10d0009f, 0x10d000b3, 0x10d000b8, 0x11700000,
+	0x117000d5, 0x11f00000, 0x11f00061, 0x12400000,
+	0x12400052, 0x12800000, 0x12b00000, 0x12b00115,
+	0x12d00000, 0x12d00043, 0x12f00000, 0x12f000a5,
+	// Entry 80 - 9F
+	0x13000000, 0x13000081, 0x13000123, 0x13600000,
+	0x1360005e, 0x13600088, 0x13900000, 0x13900001,
+	0x1390001a, 0x13900025, 0x13900026, 0x1390002d,
+	0x1390002e, 0x1390002f, 0x13900034, 0x13900036,
+	0x1390003a, 0x1390003d, 0x13900042, 0x13900046,
+	0x13900048, 0x13900049, 0x1390004a, 0x1390004e,
+	0x13900050, 0x13900052, 0x1390005d, 0x1390005e,
+	0x13900061, 0x13900062, 0x13900064, 0x13900065,
+	// Entry A0 - BF
+	0x1390006e, 0x13900073, 0x13900074, 0x13900075,
+	0x13900076, 0x1390007c, 0x1390007d, 0x13900080,
+	0x13900081, 0x13900082, 0x13900084, 0x1390008b,
+	0x1390008d, 0x1390008e, 0x13900097, 0x13900098,
+	0x13900099, 0x1390009a, 0x1390009b, 0x139000a0,
+	0x139000a1, 0x139000a5, 0x139000a8, 0x139000aa,
+	0x139000ae, 0x139000b2, 0x139000b5, 0x139000b6,
+	0x139000c0, 0x139000c1, 0x139000c7, 0x139000c8,
+	// Entry C0 - DF
+	0x139000cb, 0x139000cc, 0x139000cd, 0x139000cf,
+	0x139000d1, 0x139000d3, 0x139000d6, 0x139000d7,
+	0x139000da, 0x139000de, 0x139000e0, 0x139000e1,
+	0x139000e7, 0x139000e8, 0x139000e9, 0x139000ec,
+	0x139000ed, 0x139000f1, 0x13900108, 0x1390010a,
+	0x1390010b, 0x1390010c, 0x1390010d, 0x1390010e,
+	0x1390010f, 0x13900110, 0x13900113, 0x13900118,
+	0x1390011c, 0x1390011e, 0x13900120, 0x13900126,
+	// Entry E0 - FF
+	0x1390012a, 0x1390012d, 0x1390012e, 0x13900130,
+	0x13900132, 0x13900134, 0x13900136, 0x1390013a,
+	0x1390013d, 0x1390013e, 0x13900140, 0x13900143,
+	0x13900162, 0x13900163, 0x13900165, 0x13c00000,
+	0x13c00001, 0x13e00000, 0x13e0001f, 0x13e0002c,
+	0x13e0003f, 0x13e00041, 0x13e00048, 0x13e00051,
+	0x13e00054, 0x13e00057, 0x13e0005a, 0x13e00066,
+	0x13e00069, 0x13e0006a, 0x13e0006f, 0x13e00087,
+	// Entry 100 - 11F
+	0x13e0008a, 0x13e00090, 0x13e00095, 0x13e000d0,
+	0x13e000d9, 0x13e000e3, 0x13e000e5, 0x13e000e8,
+	0x13e000ed, 0x13e000f2, 0x13e0011b, 0x13e00136,
+	0x13e00137, 0x13e0013c, 0x14000000, 0x1400006b,
+	0x14500000, 0x1450006f, 0x14600000, 0x14600052,
+	0x14800000, 0x14800024, 0x1480009d, 0x14e00000,
+	0x14e00052, 0x14e00085, 0x14e000ca, 0x14e00115,
+	0x15100000, 0x15100073, 0x15300000, 0x153000e8,
+	// Entry 120 - 13F
+	0x15800000, 0x15800064, 0x15800077, 0x15e00000,
+	0x15e00036, 0x15e00037, 0x15e0003a, 0x15e0003b,
+	0x15e0003c, 0x15e00049, 0x15e0004b, 0x15e0004c,
+	0x15e0004d, 0x15e0004e, 0x15e0004f, 0x15e00052,
+	0x15e00063, 0x15e00068, 0x15e00079, 0x15e0007b,
+	0x15e0007f, 0x15e00085, 0x15e00086, 0x15e00087,
+	0x15e00092, 0x15e000a9, 0x15e000b8, 0x15e000bb,
+	0x15e000bc, 0x15e000bf, 0x15e000c0, 0x15e000c4,
+	// Entry 140 - 15F
+	0x15e000c9, 0x15e000ca, 0x15e000cd, 0x15e000d4,
+	0x15e000d5, 0x15e000e6, 0x15e000eb, 0x15e00103,
+	0x15e00108, 0x15e0010b, 0x15e00115, 0x15e0011d,
+	0x15e00121, 0x15e00123, 0x15e00129, 0x15e00140,
+	0x15e00141, 0x15e00160, 0x16900000, 0x1690009f,
+	0x16d00000, 0x16d000da, 0x16e00000, 0x16e00097,
+	0x17e00000, 0x17e0007c, 0x19000000, 0x1900006f,
+	0x1a300000, 0x1a30004e, 0x1a300079, 0x1a3000b3,
+	// Entry 160 - 17F
+	0x1a400000, 0x1a40009a, 0x1a900000, 0x1ab00000,
+	0x1ab000a5, 0x1ac00000, 0x1ac00099, 0x1b400000,
+	0x1b400081, 0x1b4000d5, 0x1b4000d7, 0x1b800000,
+	0x1b800136, 0x1bc00000, 0x1bc00098, 0x1be00000,
+	0x1be0009a, 0x1d100000, 0x1d100033, 0x1d100091,
+	0x1d200000, 0x1d200061, 0x1d500000, 0x1d500093,
+	0x1d700000, 0x1d700028, 0x1e100000, 0x1e100096,
+	0x1e700000, 0x1e7000d7, 0x1ea00000, 0x1ea00053,
+	// Entry 180 - 19F
+	0x1f300000, 0x1f500000, 0x1f800000, 0x1f80009e,
+	0x1f900000, 0x1f90004e, 0x1f90009f, 0x1f900114,
+	0x1f900139, 0x1fa00000, 0x1fb00000, 0x20000000,
+	0x200000a3, 0x20300000, 0x20700000, 0x20700052,
+	0x20800000, 0x20a00000, 0x20a00130, 0x20e00000,
+	0x20f00000, 0x21000000, 0x2100007e, 0x21200000,
+	0x21200068, 0x21600000, 0x21700000, 0x217000a5,
+	0x21f00000, 0x22300000, 0x22300130, 0x22700000,
+	// Entry 1A0 - 1BF
+	0x2270005b, 0x23400000, 0x234000c4, 0x23900000,
+	0x239000a5, 0x24200000, 0x242000af, 0x24400000,
+	0x24400052, 0x24500000, 0x24500083, 0x24600000,
+	0x246000a5, 0x24a00000, 0x24a000a7, 0x25100000,
+	0x2510009a, 0x25400000, 0x254000ab, 0x254000ac,
+	0x25600000, 0x2560009a, 0x26a00000, 0x26a0009a,
+	0x26b00000, 0x26b00130, 0x26d00000, 0x26d00052,
+	0x26e00000, 0x26e00061, 0x27400000, 0x28100000,
+	// Entry 1C0 - 1DF
+	0x2810007c, 0x28a00000, 0x28a000a6, 0x29100000,
+	0x29100130, 0x29500000, 0x295000b8, 0x2a300000,
+	0x2a300132, 0x2af00000, 0x2af00136, 0x2b500000,
+	0x2b50002a, 0x2b50004b, 0x2b50004c, 0x2b50004d,
+	0x2b800000, 0x2b8000b0, 0x2bf00000, 0x2bf0009c,
+	0x2bf0009d, 0x2c000000, 0x2c0000b7, 0x2c200000,
+	0x2c20004b, 0x2c400000, 0x2c4000a5, 0x2c500000,
+	0x2c5000a5, 0x2c700000, 0x2c7000b9, 0x2d100000,
+	// Entry 1E0 - 1FF
+	0x2d1000a5, 0x2d100130, 0x2e900000, 0x2e9000a5,
+	0x2ed00000, 0x2ed000cd, 0x2f100000, 0x2f1000c0,
+	0x2f200000, 0x2f2000d2, 0x2f400000, 0x2f400052,
+	0x2ff00000, 0x2ff000c3, 0x30400000, 0x3040009a,
+	0x30b00000, 0x30b000c6, 0x31000000, 0x31b00000,
+	0x31b0009a, 0x31f00000, 0x31f0003e, 0x31f000d1,
+	0x31f0010e, 0x32000000, 0x320000cc, 0x32500000,
+	0x32500052, 0x33100000, 0x331000c5, 0x33a00000,
+	// Entry 200 - 21F
+	0x33a0009d, 0x34100000, 0x34500000, 0x345000d3,
+	0x34700000, 0x347000db, 0x34700111, 0x34e00000,
+	0x34e00165, 0x35000000, 0x35000061, 0x350000da,
+	0x35100000, 0x3510009a, 0x351000dc, 0x36700000,
+	0x36700030, 0x36700036, 0x36700040, 0x3670005c,
+	0x367000da, 0x36700117, 0x3670011c, 0x36800000,
+	0x36800052, 0x36a00000, 0x36a000db, 0x36c00000,
+	0x36c00052, 0x36f00000, 0x37500000, 0x37600000,
+	// Entry 220 - 23F
+	0x37a00000, 0x38000000, 0x38000118, 0x38700000,
+	0x38900000, 0x38900132, 0x39000000, 0x39000070,
+	0x390000a5, 0x39500000, 0x3950009a, 0x39800000,
+	0x3980007e, 0x39800107, 0x39d00000, 0x39d05000,
+	0x39d050e9, 0x39d36000, 0x39d3609a, 0x3a100000,
+	0x3b300000, 0x3b3000ea, 0x3bd00000, 0x3bd00001,
+	0x3be00000, 0x3be00024, 0x3c000000, 0x3c00002a,
+	0x3c000041, 0x3c00004e, 0x3c00005b, 0x3c000087,
+	// Entry 240 - 25F
+	0x3c00008c, 0x3c0000b8, 0x3c0000c7, 0x3c0000d2,
+	0x3c0000ef, 0x3c000119, 0x3c000127, 0x3c400000,
+	0x3c40003f, 0x3c40006a, 0x3c4000e5, 0x3d400000,
+	0x3d40004e, 0x3d900000, 0x3d90003a, 0x3dc00000,
+	0x3dc000bd, 0x3dc00105, 0x3de00000, 0x3de00130,
+	0x3e200000, 0x3e200047, 0x3e2000a6, 0x3e2000af,
+	0x3e2000bd, 0x3e200107, 0x3e200131, 0x3e500000,
+	0x3e500108, 0x3e600000, 0x3e600130, 0x3eb00000,
+	// Entry 260 - 27F
+	0x3eb00107, 0x3ec00000, 0x3ec000a5, 0x3f300000,
+	0x3f300130, 0x3fa00000, 0x3fa000e9, 0x3fc00000,
+	0x3fd00000, 0x3fd00073, 0x3fd000db, 0x3fd0010d,
+	0x3ff00000, 0x3ff000d2, 0x40100000, 0x401000c4,
+	0x40200000, 0x4020004c, 0x40700000, 0x40800000,
+	0x4085b000, 0x4085b0bb, 0x408eb000, 0x408eb0bb,
+	0x40c00000, 0x40c000b4, 0x41200000, 0x41200112,
+	0x41600000, 0x41600110, 0x41c00000, 0x41d00000,
+	// Entry 280 - 29F
+	0x41e00000, 0x41f00000, 0x41f00073, 0x42200000,
+	0x42300000, 0x42300165, 0x42900000, 0x42900063,
+	0x42900070, 0x429000a5, 0x42900116, 0x43100000,
+	0x43100027, 0x431000c3, 0x4310014e, 0x43200000,
+	0x43220000, 0x43220033, 0x432200be, 0x43220106,
+	0x4322014e, 0x4325b000, 0x4325b033, 0x4325b0be,
+	0x4325b106, 0x4325b14e, 0x43700000, 0x43a00000,
+	0x43b00000, 0x44400000, 0x44400031, 0x44400073,
+	// Entry 2A0 - 2BF
+	0x4440010d, 0x44500000, 0x4450004b, 0x445000a5,
+	0x44500130, 0x44500132, 0x44e00000, 0x45000000,
+	0x4500009a, 0x450000b4, 0x450000d1, 0x4500010e,
+	0x46100000, 0x4610009a, 0x46400000, 0x464000a5,
+	0x46400132, 0x46700000, 0x46700125, 0x46b00000,
+	0x46b00124, 0x46f00000, 0x46f0006e, 0x46f00070,
+	0x47100000, 0x47600000, 0x47600128, 0x47a00000,
+	0x48000000, 0x48200000, 0x4820012a, 0x48a00000,
+	// Entry 2C0 - 2DF
+	0x48a0005e, 0x48a0012c, 0x48e00000, 0x49400000,
+	0x49400107, 0x4a400000, 0x4a4000d5, 0x4a900000,
+	0x4a9000bb, 0x4ac00000, 0x4ac00053, 0x4ae00000,
+	0x4ae00131, 0x4b400000, 0x4b40009a, 0x4b4000e9,
+	0x4bc00000, 0x4bc05000, 0x4bc05024, 0x4bc20000,
+	0x4bc20138, 0x4bc5b000, 0x4bc5b138, 0x4be00000,
+	0x4be5b000, 0x4be5b0b5, 0x4bef4000, 0x4bef40b5,
+	0x4c000000, 0x4c300000, 0x4c30013f, 0x4c900000,
+	// Entry 2E0 - 2FF
+	0x4c900001, 0x4cc00000, 0x4cc00130, 0x4ce00000,
+	0x4cf00000, 0x4cf0004e, 0x4e500000, 0x4e500115,
+	0x4f200000, 0x4fb00000, 0x4fb00132, 0x50900000,
+	0x50900052, 0x51200000, 0x51200001, 0x51800000,
+	0x5180003b, 0x518000d7, 0x51f00000, 0x51f3b000,
+	0x51f3b053, 0x51f3c000, 0x51f3c08e, 0x52800000,
+	0x528000bb, 0x52900000, 0x5293b000, 0x5293b053,
+	0x5293b08e, 0x5293b0c7, 0x5293b10e, 0x5293c000,
+	// Entry 300 - 31F
+	0x5293c08e, 0x5293c0c7, 0x5293c12f, 0x52f00000,
+	0x52f00162,
+} // Size: 3116 bytes
+
+const specialTagsStr string = "ca-ES-valencia en-US-u-va-posix"
+
+// Total table size 3147 bytes (3KiB); checksum: 5A8FFFA5
diff --git a/vendor/golang.org/x/text/internal/language/compact/tags.go b/vendor/golang.org/x/text/internal/language/compact/tags.go
new file mode 100644
index 00000000000..ca135d295ae
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/compact/tags.go
@@ -0,0 +1,91 @@
+// 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 compact
+
+var (
+	und = Tag{}
+
+	Und Tag = Tag{}
+
+	Afrikaans            Tag = Tag{language: afIndex, locale: afIndex}
+	Amharic              Tag = Tag{language: amIndex, locale: amIndex}
+	Arabic               Tag = Tag{language: arIndex, locale: arIndex}
+	ModernStandardArabic Tag = Tag{language: ar001Index, locale: ar001Index}
+	Azerbaijani          Tag = Tag{language: azIndex, locale: azIndex}
+	Bulgarian            Tag = Tag{language: bgIndex, locale: bgIndex}
+	Bengali              Tag = Tag{language: bnIndex, locale: bnIndex}
+	Catalan              Tag = Tag{language: caIndex, locale: caIndex}
+	Czech                Tag = Tag{language: csIndex, locale: csIndex}
+	Danish               Tag = Tag{language: daIndex, locale: daIndex}
+	German               Tag = Tag{language: deIndex, locale: deIndex}
+	Greek                Tag = Tag{language: elIndex, locale: elIndex}
+	English              Tag = Tag{language: enIndex, locale: enIndex}
+	AmericanEnglish      Tag = Tag{language: enUSIndex, locale: enUSIndex}
+	BritishEnglish       Tag = Tag{language: enGBIndex, locale: enGBIndex}
+	Spanish              Tag = Tag{language: esIndex, locale: esIndex}
+	EuropeanSpanish      Tag = Tag{language: esESIndex, locale: esESIndex}
+	LatinAmericanSpanish Tag = Tag{language: es419Index, locale: es419Index}
+	Estonian             Tag = Tag{language: etIndex, locale: etIndex}
+	Persian              Tag = Tag{language: faIndex, locale: faIndex}
+	Finnish              Tag = Tag{language: fiIndex, locale: fiIndex}
+	Filipino             Tag = Tag{language: filIndex, locale: filIndex}
+	French               Tag = Tag{language: frIndex, locale: frIndex}
+	CanadianFrench       Tag = Tag{language: frCAIndex, locale: frCAIndex}
+	Gujarati             Tag = Tag{language: guIndex, locale: guIndex}
+	Hebrew               Tag = Tag{language: heIndex, locale: heIndex}
+	Hindi                Tag = Tag{language: hiIndex, locale: hiIndex}
+	Croatian             Tag = Tag{language: hrIndex, locale: hrIndex}
+	Hungarian            Tag = Tag{language: huIndex, locale: huIndex}
+	Armenian             Tag = Tag{language: hyIndex, locale: hyIndex}
+	Indonesian           Tag = Tag{language: idIndex, locale: idIndex}
+	Icelandic            Tag = Tag{language: isIndex, locale: isIndex}
+	Italian              Tag = Tag{language: itIndex, locale: itIndex}
+	Japanese             Tag = Tag{language: jaIndex, locale: jaIndex}
+	Georgian             Tag = Tag{language: kaIndex, locale: kaIndex}
+	Kazakh               Tag = Tag{language: kkIndex, locale: kkIndex}
+	Khmer                Tag = Tag{language: kmIndex, locale: kmIndex}
+	Kannada              Tag = Tag{language: knIndex, locale: knIndex}
+	Korean               Tag = Tag{language: koIndex, locale: koIndex}
+	Kirghiz              Tag = Tag{language: kyIndex, locale: kyIndex}
+	Lao                  Tag = Tag{language: loIndex, locale: loIndex}
+	Lithuanian           Tag = Tag{language: ltIndex, locale: ltIndex}
+	Latvian              Tag = Tag{language: lvIndex, locale: lvIndex}
+	Macedonian           Tag = Tag{language: mkIndex, locale: mkIndex}
+	Malayalam            Tag = Tag{language: mlIndex, locale: mlIndex}
+	Mongolian            Tag = Tag{language: mnIndex, locale: mnIndex}
+	Marathi              Tag = Tag{language: mrIndex, locale: mrIndex}
+	Malay                Tag = Tag{language: msIndex, locale: msIndex}
+	Burmese              Tag = Tag{language: myIndex, locale: myIndex}
+	Nepali               Tag = Tag{language: neIndex, locale: neIndex}
+	Dutch                Tag = Tag{language: nlIndex, locale: nlIndex}
+	Norwegian            Tag = Tag{language: noIndex, locale: noIndex}
+	Punjabi              Tag = Tag{language: paIndex, locale: paIndex}
+	Polish               Tag = Tag{language: plIndex, locale: plIndex}
+	Portuguese           Tag = Tag{language: ptIndex, locale: ptIndex}
+	BrazilianPortuguese  Tag = Tag{language: ptBRIndex, locale: ptBRIndex}
+	EuropeanPortuguese   Tag = Tag{language: ptPTIndex, locale: ptPTIndex}
+	Romanian             Tag = Tag{language: roIndex, locale: roIndex}
+	Russian              Tag = Tag{language: ruIndex, locale: ruIndex}
+	Sinhala              Tag = Tag{language: siIndex, locale: siIndex}
+	Slovak               Tag = Tag{language: skIndex, locale: skIndex}
+	Slovenian            Tag = Tag{language: slIndex, locale: slIndex}
+	Albanian             Tag = Tag{language: sqIndex, locale: sqIndex}
+	Serbian              Tag = Tag{language: srIndex, locale: srIndex}
+	SerbianLatin         Tag = Tag{language: srLatnIndex, locale: srLatnIndex}
+	Swedish              Tag = Tag{language: svIndex, locale: svIndex}
+	Swahili              Tag = Tag{language: swIndex, locale: swIndex}
+	Tamil                Tag = Tag{language: taIndex, locale: taIndex}
+	Telugu               Tag = Tag{language: teIndex, locale: teIndex}
+	Thai                 Tag = Tag{language: thIndex, locale: thIndex}
+	Turkish              Tag = Tag{language: trIndex, locale: trIndex}
+	Ukrainian            Tag = Tag{language: ukIndex, locale: ukIndex}
+	Urdu                 Tag = Tag{language: urIndex, locale: urIndex}
+	Uzbek                Tag = Tag{language: uzIndex, locale: uzIndex}
+	Vietnamese           Tag = Tag{language: viIndex, locale: viIndex}
+	Chinese              Tag = Tag{language: zhIndex, locale: zhIndex}
+	SimplifiedChinese    Tag = Tag{language: zhHansIndex, locale: zhHansIndex}
+	TraditionalChinese   Tag = Tag{language: zhHantIndex, locale: zhHantIndex}
+	Zulu                 Tag = Tag{language: zuIndex, locale: zuIndex}
+)
diff --git a/vendor/golang.org/x/text/internal/language/compose.go b/vendor/golang.org/x/text/internal/language/compose.go
new file mode 100644
index 00000000000..4ae78e0fa5f
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/compose.go
@@ -0,0 +1,167 @@
+// Copyright 2018 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+package language
+
+import (
+	"sort"
+	"strings"
+)
+
+// A Builder allows constructing a Tag from individual components.
+// Its main user is Compose in the top-level language package.
+type Builder struct {
+	Tag Tag
+
+	private    string // the x extension
+	variants   []string
+	extensions []string
+}
+
+// Make returns a new Tag from the current settings.
+func (b *Builder) Make() Tag {
+	t := b.Tag
+
+	if len(b.extensions) > 0 || len(b.variants) > 0 {
+		sort.Sort(sortVariants(b.variants))
+		sort.Strings(b.extensions)
+
+		if b.private != "" {
+			b.extensions = append(b.extensions, b.private)
+		}
+		n := maxCoreSize + tokenLen(b.variants...) + tokenLen(b.extensions...)
+		buf := make([]byte, n)
+		p := t.genCoreBytes(buf)
+		t.pVariant = byte(p)
+		p += appendTokens(buf[p:], b.variants...)
+		t.pExt = uint16(p)
+		p += appendTokens(buf[p:], b.extensions...)
+		t.str = string(buf[:p])
+		// We may not always need to remake the string, but when or when not
+		// to do so is rather tricky.
+		scan := makeScanner(buf[:p])
+		t, _ = parse(&scan, "")
+		return t
+
+	} else if b.private != "" {
+		t.str = b.private
+		t.RemakeString()
+	}
+	return t
+}
+
+// SetTag copies all the settings from a given Tag. Any previously set values
+// are discarded.
+func (b *Builder) SetTag(t Tag) {
+	b.Tag.LangID = t.LangID
+	b.Tag.RegionID = t.RegionID
+	b.Tag.ScriptID = t.ScriptID
+	// TODO: optimize
+	b.variants = b.variants[:0]
+	if variants := t.Variants(); variants != "" {
+		for _, vr := range strings.Split(variants[1:], "-") {
+			b.variants = append(b.variants, vr)
+		}
+	}
+	b.extensions, b.private = b.extensions[:0], ""
+	for _, e := range t.Extensions() {
+		b.AddExt(e)
+	}
+}
+
+// AddExt adds extension e to the tag. e must be a valid extension as returned
+// by Tag.Extension. If the extension already exists, it will be discarded,
+// except for a -u extension, where non-existing key-type pairs will added.
+func (b *Builder) AddExt(e string) {
+	if e[0] == 'x' {
+		if b.private == "" {
+			b.private = e
+		}
+		return
+	}
+	for i, s := range b.extensions {
+		if s[0] == e[0] {
+			if e[0] == 'u' {
+				b.extensions[i] += e[1:]
+			}
+			return
+		}
+	}
+	b.extensions = append(b.extensions, e)
+}
+
+// SetExt sets the extension e to the tag. e must be a valid extension as
+// returned by Tag.Extension. If the extension already exists, it will be
+// overwritten, except for a -u extension, where the individual key-type pairs
+// will be set.
+func (b *Builder) SetExt(e string) {
+	if e[0] == 'x' {
+		b.private = e
+		return
+	}
+	for i, s := range b.extensions {
+		if s[0] == e[0] {
+			if e[0] == 'u' {
+				b.extensions[i] = e + s[1:]
+			} else {
+				b.extensions[i] = e
+			}
+			return
+		}
+	}
+	b.extensions = append(b.extensions, e)
+}
+
+// AddVariant adds any number of variants.
+func (b *Builder) AddVariant(v ...string) {
+	for _, v := range v {
+		if v != "" {
+			b.variants = append(b.variants, v)
+		}
+	}
+}
+
+// ClearVariants removes any variants previously added, including those
+// copied from a Tag in SetTag.
+func (b *Builder) ClearVariants() {
+	b.variants = b.variants[:0]
+}
+
+// ClearExtensions removes any extensions previously added, including those
+// copied from a Tag in SetTag.
+func (b *Builder) ClearExtensions() {
+	b.private = ""
+	b.extensions = b.extensions[:0]
+}
+
+func tokenLen(token ...string) (n int) {
+	for _, t := range token {
+		n += len(t) + 1
+	}
+	return
+}
+
+func appendTokens(b []byte, token ...string) int {
+	p := 0
+	for _, t := range token {
+		b[p] = '-'
+		copy(b[p+1:], t)
+		p += 1 + len(t)
+	}
+	return p
+}
+
+type sortVariants []string
+
+func (s sortVariants) Len() int {
+	return len(s)
+}
+
+func (s sortVariants) Swap(i, j int) {
+	s[j], s[i] = s[i], s[j]
+}
+
+func (s sortVariants) Less(i, j int) bool {
+	return variantIndex[s[i]] < variantIndex[s[j]]
+}
diff --git a/vendor/golang.org/x/text/internal/language/coverage.go b/vendor/golang.org/x/text/internal/language/coverage.go
new file mode 100644
index 00000000000..9b20b88feb8
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/coverage.go
@@ -0,0 +1,28 @@
+// Copyright 2014 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 language
+
+// BaseLanguages returns the list of all supported base languages. It generates
+// the list by traversing the internal structures.
+func BaseLanguages() []Language {
+	base := make([]Language, 0, NumLanguages)
+	for i := 0; i < langNoIndexOffset; i++ {
+		// We included "und" already for the value 0.
+		if i != nonCanonicalUnd {
+			base = append(base, Language(i))
+		}
+	}
+	i := langNoIndexOffset
+	for _, v := range langNoIndex {
+		for k := 0; k < 8; k++ {
+			if v&1 == 1 {
+				base = append(base, Language(i))
+			}
+			v >>= 1
+			i++
+		}
+	}
+	return base
+}
diff --git a/vendor/golang.org/x/text/internal/language/language.go b/vendor/golang.org/x/text/internal/language/language.go
new file mode 100644
index 00000000000..09d41c73670
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/language.go
@@ -0,0 +1,627 @@
+// 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.
+
+//go:generate go run gen.go gen_common.go -output tables.go
+
+package language // import "golang.org/x/text/internal/language"
+
+// TODO: Remove above NOTE after:
+// - verifying that tables are dropped correctly (most notably matcher tables).
+
+import (
+	"errors"
+	"fmt"
+	"strings"
+)
+
+const (
+	// maxCoreSize is the maximum size of a BCP 47 tag without variants and
+	// extensions. Equals max lang (3) + script (4) + max reg (3) + 2 dashes.
+	maxCoreSize = 12
+
+	// max99thPercentileSize is a somewhat arbitrary buffer size that presumably
+	// is large enough to hold at least 99% of the BCP 47 tags.
+	max99thPercentileSize = 32
+
+	// maxSimpleUExtensionSize is the maximum size of a -u extension with one
+	// key-type pair. Equals len("-u-") + key (2) + dash + max value (8).
+	maxSimpleUExtensionSize = 14
+)
+
+// Tag represents a BCP 47 language tag. It is used to specify an instance of a
+// specific language or locale. All language tag values are guaranteed to be
+// well-formed. The zero value of Tag is Und.
+type Tag struct {
+	// TODO: the following fields have the form TagTypeID. This name is chosen
+	// to allow refactoring the public package without conflicting with its
+	// Base, Script, and Region methods. Once the transition is fully completed
+	// the ID can be stripped from the name.
+
+	LangID   Language
+	RegionID Region
+	// TODO: we will soon run out of positions for ScriptID. Idea: instead of
+	// storing lang, region, and ScriptID codes, store only the compact index and
+	// have a lookup table from this code to its expansion. This greatly speeds
+	// up table lookup, speed up common variant cases.
+	// This will also immediately free up 3 extra bytes. Also, the pVariant
+	// field can now be moved to the lookup table, as the compact index uniquely
+	// determines the offset of a possible variant.
+	ScriptID Script
+	pVariant byte   // offset in str, includes preceding '-'
+	pExt     uint16 // offset of first extension, includes preceding '-'
+
+	// str is the string representation of the Tag. It will only be used if the
+	// tag has variants or extensions.
+	str string
+}
+
+// Make is a convenience wrapper for Parse that omits the error.
+// In case of an error, a sensible default is returned.
+func Make(s string) Tag {
+	t, _ := Parse(s)
+	return t
+}
+
+// Raw returns the raw base language, script and region, without making an
+// attempt to infer their values.
+// TODO: consider removing
+func (t Tag) Raw() (b Language, s Script, r Region) {
+	return t.LangID, t.ScriptID, t.RegionID
+}
+
+// equalTags compares language, script and region subtags only.
+func (t Tag) equalTags(a Tag) bool {
+	return t.LangID == a.LangID && t.ScriptID == a.ScriptID && t.RegionID == a.RegionID
+}
+
+// IsRoot returns true if t is equal to language "und".
+func (t Tag) IsRoot() bool {
+	if int(t.pVariant) < len(t.str) {
+		return false
+	}
+	return t.equalTags(Und)
+}
+
+// IsPrivateUse reports whether the Tag consists solely of an IsPrivateUse use
+// tag.
+func (t Tag) IsPrivateUse() bool {
+	return t.str != "" && t.pVariant == 0
+}
+
+// RemakeString is used to update t.str in case lang, script or region changed.
+// It is assumed that pExt and pVariant still point to the start of the
+// respective parts.
+func (t *Tag) RemakeString() {
+	if t.str == "" {
+		return
+	}
+	extra := t.str[t.pVariant:]
+	if t.pVariant > 0 {
+		extra = extra[1:]
+	}
+	if t.equalTags(Und) && strings.HasPrefix(extra, "x-") {
+		t.str = extra
+		t.pVariant = 0
+		t.pExt = 0
+		return
+	}
+	var buf [max99thPercentileSize]byte // avoid extra memory allocation in most cases.
+	b := buf[:t.genCoreBytes(buf[:])]
+	if extra != "" {
+		diff := len(b) - int(t.pVariant)
+		b = append(b, '-')
+		b = append(b, extra...)
+		t.pVariant = uint8(int(t.pVariant) + diff)
+		t.pExt = uint16(int(t.pExt) + diff)
+	} else {
+		t.pVariant = uint8(len(b))
+		t.pExt = uint16(len(b))
+	}
+	t.str = string(b)
+}
+
+// genCoreBytes writes a string for the base languages, script and region tags
+// to the given buffer and returns the number of bytes written. It will never
+// write more than maxCoreSize bytes.
+func (t *Tag) genCoreBytes(buf []byte) int {
+	n := t.LangID.StringToBuf(buf[:])
+	if t.ScriptID != 0 {
+		n += copy(buf[n:], "-")
+		n += copy(buf[n:], t.ScriptID.String())
+	}
+	if t.RegionID != 0 {
+		n += copy(buf[n:], "-")
+		n += copy(buf[n:], t.RegionID.String())
+	}
+	return n
+}
+
+// String returns the canonical string representation of the language tag.
+func (t Tag) String() string {
+	if t.str != "" {
+		return t.str
+	}
+	if t.ScriptID == 0 && t.RegionID == 0 {
+		return t.LangID.String()
+	}
+	buf := [maxCoreSize]byte{}
+	return string(buf[:t.genCoreBytes(buf[:])])
+}
+
+// MarshalText implements encoding.TextMarshaler.
+func (t Tag) MarshalText() (text []byte, err error) {
+	if t.str != "" {
+		text = append(text, t.str...)
+	} else if t.ScriptID == 0 && t.RegionID == 0 {
+		text = append(text, t.LangID.String()...)
+	} else {
+		buf := [maxCoreSize]byte{}
+		text = buf[:t.genCoreBytes(buf[:])]
+	}
+	return text, nil
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler.
+func (t *Tag) UnmarshalText(text []byte) error {
+	tag, err := Parse(string(text))
+	*t = tag
+	return err
+}
+
+// Variants returns the part of the tag holding all variants or the empty string
+// if there are no variants defined.
+func (t Tag) Variants() string {
+	if t.pVariant == 0 {
+		return ""
+	}
+	return t.str[t.pVariant:t.pExt]
+}
+
+// VariantOrPrivateUseTags returns variants or private use tags.
+func (t Tag) VariantOrPrivateUseTags() string {
+	if t.pExt > 0 {
+		return t.str[t.pVariant:t.pExt]
+	}
+	return t.str[t.pVariant:]
+}
+
+// HasString reports whether this tag defines more than just the raw
+// components.
+func (t Tag) HasString() bool {
+	return t.str != ""
+}
+
+// Parent returns the CLDR parent of t. In CLDR, missing fields in data for a
+// specific language are substituted with fields from the parent language.
+// The parent for a language may change for newer versions of CLDR.
+func (t Tag) Parent() Tag {
+	if t.str != "" {
+		// Strip the variants and extensions.
+		b, s, r := t.Raw()
+		t = Tag{LangID: b, ScriptID: s, RegionID: r}
+		if t.RegionID == 0 && t.ScriptID != 0 && t.LangID != 0 {
+			base, _ := addTags(Tag{LangID: t.LangID})
+			if base.ScriptID == t.ScriptID {
+				return Tag{LangID: t.LangID}
+			}
+		}
+		return t
+	}
+	if t.LangID != 0 {
+		if t.RegionID != 0 {
+			maxScript := t.ScriptID
+			if maxScript == 0 {
+				max, _ := addTags(t)
+				maxScript = max.ScriptID
+			}
+
+			for i := range parents {
+				if Language(parents[i].lang) == t.LangID && Script(parents[i].maxScript) == maxScript {
+					for _, r := range parents[i].fromRegion {
+						if Region(r) == t.RegionID {
+							return Tag{
+								LangID:   t.LangID,
+								ScriptID: Script(parents[i].script),
+								RegionID: Region(parents[i].toRegion),
+							}
+						}
+					}
+				}
+			}
+
+			// Strip the script if it is the default one.
+			base, _ := addTags(Tag{LangID: t.LangID})
+			if base.ScriptID != maxScript {
+				return Tag{LangID: t.LangID, ScriptID: maxScript}
+			}
+			return Tag{LangID: t.LangID}
+		} else if t.ScriptID != 0 {
+			// The parent for an base-script pair with a non-default script is
+			// "und" instead of the base language.
+			base, _ := addTags(Tag{LangID: t.LangID})
+			if base.ScriptID != t.ScriptID {
+				return Und
+			}
+			return Tag{LangID: t.LangID}
+		}
+	}
+	return Und
+}
+
+// ParseExtension parses s as an extension and returns it on success.
+func ParseExtension(s string) (ext string, err error) {
+	defer func() {
+		if recover() != nil {
+			ext = ""
+			err = ErrSyntax
+		}
+	}()
+
+	scan := makeScannerString(s)
+	var end int
+	if n := len(scan.token); n != 1 {
+		return "", ErrSyntax
+	}
+	scan.toLower(0, len(scan.b))
+	end = parseExtension(&scan)
+	if end != len(s) {
+		return "", ErrSyntax
+	}
+	return string(scan.b), nil
+}
+
+// HasVariants reports whether t has variants.
+func (t Tag) HasVariants() bool {
+	return uint16(t.pVariant) < t.pExt
+}
+
+// HasExtensions reports whether t has extensions.
+func (t Tag) HasExtensions() bool {
+	return int(t.pExt) < len(t.str)
+}
+
+// Extension returns the extension of type x for tag t. It will return
+// false for ok if t does not have the requested extension. The returned
+// extension will be invalid in this case.
+func (t Tag) Extension(x byte) (ext string, ok bool) {
+	for i := int(t.pExt); i < len(t.str)-1; {
+		var ext string
+		i, ext = getExtension(t.str, i)
+		if ext[0] == x {
+			return ext, true
+		}
+	}
+	return "", false
+}
+
+// Extensions returns all extensions of t.
+func (t Tag) Extensions() []string {
+	e := []string{}
+	for i := int(t.pExt); i < len(t.str)-1; {
+		var ext string
+		i, ext = getExtension(t.str, i)
+		e = append(e, ext)
+	}
+	return e
+}
+
+// TypeForKey returns the type associated with the given key, where key and type
+// are of the allowed values defined for the Unicode locale extension ('u') in
+// https://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers.
+// TypeForKey will traverse the inheritance chain to get the correct value.
+//
+// If there are multiple types associated with a key, only the first will be
+// returned. If there is no type associated with a key, it returns the empty
+// string.
+func (t Tag) TypeForKey(key string) string {
+	if _, start, end, _ := t.findTypeForKey(key); end != start {
+		s := t.str[start:end]
+		if p := strings.IndexByte(s, '-'); p >= 0 {
+			s = s[:p]
+		}
+		return s
+	}
+	return ""
+}
+
+var (
+	errPrivateUse       = errors.New("cannot set a key on a private use tag")
+	errInvalidArguments = errors.New("invalid key or type")
+)
+
+// SetTypeForKey returns a new Tag with the key set to type, where key and type
+// are of the allowed values defined for the Unicode locale extension ('u') in
+// https://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers.
+// An empty value removes an existing pair with the same key.
+func (t Tag) SetTypeForKey(key, value string) (Tag, error) {
+	if t.IsPrivateUse() {
+		return t, errPrivateUse
+	}
+	if len(key) != 2 {
+		return t, errInvalidArguments
+	}
+
+	// Remove the setting if value is "".
+	if value == "" {
+		start, sep, end, _ := t.findTypeForKey(key)
+		if start != sep {
+			// Remove a possible empty extension.
+			switch {
+			case t.str[start-2] != '-': // has previous elements.
+			case end == len(t.str), // end of string
+				end+2 < len(t.str) && t.str[end+2] == '-': // end of extension
+				start -= 2
+			}
+			if start == int(t.pVariant) && end == len(t.str) {
+				t.str = ""
+				t.pVariant, t.pExt = 0, 0
+			} else {
+				t.str = fmt.Sprintf("%s%s", t.str[:start], t.str[end:])
+			}
+		}
+		return t, nil
+	}
+
+	if len(value) < 3 || len(value) > 8 {
+		return t, errInvalidArguments
+	}
+
+	var (
+		buf    [maxCoreSize + maxSimpleUExtensionSize]byte
+		uStart int // start of the -u extension.
+	)
+
+	// Generate the tag string if needed.
+	if t.str == "" {
+		uStart = t.genCoreBytes(buf[:])
+		buf[uStart] = '-'
+		uStart++
+	}
+
+	// Create new key-type pair and parse it to verify.
+	b := buf[uStart:]
+	copy(b, "u-")
+	copy(b[2:], key)
+	b[4] = '-'
+	b = b[:5+copy(b[5:], value)]
+	scan := makeScanner(b)
+	if parseExtensions(&scan); scan.err != nil {
+		return t, scan.err
+	}
+
+	// Assemble the replacement string.
+	if t.str == "" {
+		t.pVariant, t.pExt = byte(uStart-1), uint16(uStart-1)
+		t.str = string(buf[:uStart+len(b)])
+	} else {
+		s := t.str
+		start, sep, end, hasExt := t.findTypeForKey(key)
+		if start == sep {
+			if hasExt {
+				b = b[2:]
+			}
+			t.str = fmt.Sprintf("%s-%s%s", s[:sep], b, s[end:])
+		} else {
+			t.str = fmt.Sprintf("%s-%s%s", s[:start+3], value, s[end:])
+		}
+	}
+	return t, nil
+}
+
+// findTypeForKey returns the start and end position for the type corresponding
+// to key or the point at which to insert the key-value pair if the type
+// wasn't found. The hasExt return value reports whether an -u extension was present.
+// Note: the extensions are typically very small and are likely to contain
+// only one key-type pair.
+func (t Tag) findTypeForKey(key string) (start, sep, end int, hasExt bool) {
+	p := int(t.pExt)
+	if len(key) != 2 || p == len(t.str) || p == 0 {
+		return p, p, p, false
+	}
+	s := t.str
+
+	// Find the correct extension.
+	for p++; s[p] != 'u'; p++ {
+		if s[p] > 'u' {
+			p--
+			return p, p, p, false
+		}
+		if p = nextExtension(s, p); p == len(s) {
+			return len(s), len(s), len(s), false
+		}
+	}
+	// Proceed to the hyphen following the extension name.
+	p++
+
+	// curKey is the key currently being processed.
+	curKey := ""
+
+	// Iterate over keys until we get the end of a section.
+	for {
+		end = p
+		for p++; p < len(s) && s[p] != '-'; p++ {
+		}
+		n := p - end - 1
+		if n <= 2 && curKey == key {
+			if sep < end {
+				sep++
+			}
+			return start, sep, end, true
+		}
+		switch n {
+		case 0, // invalid string
+			1: // next extension
+			return end, end, end, true
+		case 2:
+			// next key
+			curKey = s[end+1 : p]
+			if curKey > key {
+				return end, end, end, true
+			}
+			start = end
+			sep = p
+		}
+	}
+}
+
+// ParseBase parses a 2- or 3-letter ISO 639 code.
+// It returns a ValueError if s is a well-formed but unknown language identifier
+// or another error if another error occurred.
+func ParseBase(s string) (l Language, err error) {
+	defer func() {
+		if recover() != nil {
+			l = 0
+			err = ErrSyntax
+		}
+	}()
+
+	if n := len(s); n < 2 || 3 < n {
+		return 0, ErrSyntax
+	}
+	var buf [3]byte
+	return getLangID(buf[:copy(buf[:], s)])
+}
+
+// ParseScript parses a 4-letter ISO 15924 code.
+// It returns a ValueError if s is a well-formed but unknown script identifier
+// or another error if another error occurred.
+func ParseScript(s string) (scr Script, err error) {
+	defer func() {
+		if recover() != nil {
+			scr = 0
+			err = ErrSyntax
+		}
+	}()
+
+	if len(s) != 4 {
+		return 0, ErrSyntax
+	}
+	var buf [4]byte
+	return getScriptID(script, buf[:copy(buf[:], s)])
+}
+
+// EncodeM49 returns the Region for the given UN M.49 code.
+// It returns an error if r is not a valid code.
+func EncodeM49(r int) (Region, error) {
+	return getRegionM49(r)
+}
+
+// ParseRegion parses a 2- or 3-letter ISO 3166-1 or a UN M.49 code.
+// It returns a ValueError if s is a well-formed but unknown region identifier
+// or another error if another error occurred.
+func ParseRegion(s string) (r Region, err error) {
+	defer func() {
+		if recover() != nil {
+			r = 0
+			err = ErrSyntax
+		}
+	}()
+
+	if n := len(s); n < 2 || 3 < n {
+		return 0, ErrSyntax
+	}
+	var buf [3]byte
+	return getRegionID(buf[:copy(buf[:], s)])
+}
+
+// IsCountry returns whether this region is a country or autonomous area. This
+// includes non-standard definitions from CLDR.
+func (r Region) IsCountry() bool {
+	if r == 0 || r.IsGroup() || r.IsPrivateUse() && r != _XK {
+		return false
+	}
+	return true
+}
+
+// IsGroup returns whether this region defines a collection of regions. This
+// includes non-standard definitions from CLDR.
+func (r Region) IsGroup() bool {
+	if r == 0 {
+		return false
+	}
+	return int(regionInclusion[r]) < len(regionContainment)
+}
+
+// Contains returns whether Region c is contained by Region r. It returns true
+// if c == r.
+func (r Region) Contains(c Region) bool {
+	if r == c {
+		return true
+	}
+	g := regionInclusion[r]
+	if g >= nRegionGroups {
+		return false
+	}
+	m := regionContainment[g]
+
+	d := regionInclusion[c]
+	b := regionInclusionBits[d]
+
+	// A contained country may belong to multiple disjoint groups. Matching any
+	// of these indicates containment. If the contained region is a group, it
+	// must strictly be a subset.
+	if d >= nRegionGroups {
+		return b&m != 0
+	}
+	return b&^m == 0
+}
+
+var errNoTLD = errors.New("language: region is not a valid ccTLD")
+
+// TLD returns the country code top-level domain (ccTLD). UK is returned for GB.
+// In all other cases it returns either the region itself or an error.
+//
+// This method may return an error for a region for which there exists a
+// canonical form with a ccTLD. To get that ccTLD canonicalize r first. The
+// region will already be canonicalized it was obtained from a Tag that was
+// obtained using any of the default methods.
+func (r Region) TLD() (Region, error) {
+	// See http://en.wikipedia.org/wiki/Country_code_top-level_domain for the
+	// difference between ISO 3166-1 and IANA ccTLD.
+	if r == _GB {
+		r = _UK
+	}
+	if (r.typ() & ccTLD) == 0 {
+		return 0, errNoTLD
+	}
+	return r, nil
+}
+
+// Canonicalize returns the region or a possible replacement if the region is
+// deprecated. It will not return a replacement for deprecated regions that
+// are split into multiple regions.
+func (r Region) Canonicalize() Region {
+	if cr := normRegion(r); cr != 0 {
+		return cr
+	}
+	return r
+}
+
+// Variant represents a registered variant of a language as defined by BCP 47.
+type Variant struct {
+	ID  uint8
+	str string
+}
+
+// ParseVariant parses and returns a Variant. An error is returned if s is not
+// a valid variant.
+func ParseVariant(s string) (v Variant, err error) {
+	defer func() {
+		if recover() != nil {
+			v = Variant{}
+			err = ErrSyntax
+		}
+	}()
+
+	s = strings.ToLower(s)
+	if id, ok := variantIndex[s]; ok {
+		return Variant{id, s}, nil
+	}
+	return Variant{}, NewValueError([]byte(s))
+}
+
+// String returns the string representation of the variant.
+func (v Variant) String() string {
+	return v.str
+}
diff --git a/vendor/golang.org/x/text/internal/language/lookup.go b/vendor/golang.org/x/text/internal/language/lookup.go
new file mode 100644
index 00000000000..231b4fbdebf
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/lookup.go
@@ -0,0 +1,412 @@
+// 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 language
+
+import (
+	"bytes"
+	"fmt"
+	"sort"
+	"strconv"
+
+	"golang.org/x/text/internal/tag"
+)
+
+// findIndex tries to find the given tag in idx and returns a standardized error
+// if it could not be found.
+func findIndex(idx tag.Index, key []byte, form string) (index int, err error) {
+	if !tag.FixCase(form, key) {
+		return 0, ErrSyntax
+	}
+	i := idx.Index(key)
+	if i == -1 {
+		return 0, NewValueError(key)
+	}
+	return i, nil
+}
+
+func searchUint(imap []uint16, key uint16) int {
+	return sort.Search(len(imap), func(i int) bool {
+		return imap[i] >= key
+	})
+}
+
+type Language uint16
+
+// getLangID returns the langID of s if s is a canonical subtag
+// or langUnknown if s is not a canonical subtag.
+func getLangID(s []byte) (Language, error) {
+	if len(s) == 2 {
+		return getLangISO2(s)
+	}
+	return getLangISO3(s)
+}
+
+// TODO language normalization as well as the AliasMaps could be moved to the
+// higher level package, but it is a bit tricky to separate the generation.
+
+func (id Language) Canonicalize() (Language, AliasType) {
+	return normLang(id)
+}
+
+// normLang returns the mapped langID of id according to mapping m.
+func normLang(id Language) (Language, AliasType) {
+	k := sort.Search(len(AliasMap), func(i int) bool {
+		return AliasMap[i].From >= uint16(id)
+	})
+	if k < len(AliasMap) && AliasMap[k].From == uint16(id) {
+		return Language(AliasMap[k].To), AliasTypes[k]
+	}
+	return id, AliasTypeUnknown
+}
+
+// getLangISO2 returns the langID for the given 2-letter ISO language code
+// or unknownLang if this does not exist.
+func getLangISO2(s []byte) (Language, error) {
+	if !tag.FixCase("zz", s) {
+		return 0, ErrSyntax
+	}
+	if i := lang.Index(s); i != -1 && lang.Elem(i)[3] != 0 {
+		return Language(i), nil
+	}
+	return 0, NewValueError(s)
+}
+
+const base = 'z' - 'a' + 1
+
+func strToInt(s []byte) uint {
+	v := uint(0)
+	for i := 0; i < len(s); i++ {
+		v *= base
+		v += uint(s[i] - 'a')
+	}
+	return v
+}
+
+// converts the given integer to the original ASCII string passed to strToInt.
+// len(s) must match the number of characters obtained.
+func intToStr(v uint, s []byte) {
+	for i := len(s) - 1; i >= 0; i-- {
+		s[i] = byte(v%base) + 'a'
+		v /= base
+	}
+}
+
+// getLangISO3 returns the langID for the given 3-letter ISO language code
+// or unknownLang if this does not exist.
+func getLangISO3(s []byte) (Language, error) {
+	if tag.FixCase("und", s) {
+		// first try to match canonical 3-letter entries
+		for i := lang.Index(s[:2]); i != -1; i = lang.Next(s[:2], i) {
+			if e := lang.Elem(i); e[3] == 0 && e[2] == s[2] {
+				// We treat "und" as special and always translate it to "unspecified".
+				// Note that ZZ and Zzzz are private use and are not treated as
+				// unspecified by default.
+				id := Language(i)
+				if id == nonCanonicalUnd {
+					return 0, nil
+				}
+				return id, nil
+			}
+		}
+		if i := altLangISO3.Index(s); i != -1 {
+			return Language(altLangIndex[altLangISO3.Elem(i)[3]]), nil
+		}
+		n := strToInt(s)
+		if langNoIndex[n/8]&(1<<(n%8)) != 0 {
+			return Language(n) + langNoIndexOffset, nil
+		}
+		// Check for non-canonical uses of ISO3.
+		for i := lang.Index(s[:1]); i != -1; i = lang.Next(s[:1], i) {
+			if e := lang.Elem(i); e[2] == s[1] && e[3] == s[2] {
+				return Language(i), nil
+			}
+		}
+		return 0, NewValueError(s)
+	}
+	return 0, ErrSyntax
+}
+
+// StringToBuf writes the string to b and returns the number of bytes
+// written.  cap(b) must be >= 3.
+func (id Language) StringToBuf(b []byte) int {
+	if id >= langNoIndexOffset {
+		intToStr(uint(id)-langNoIndexOffset, b[:3])
+		return 3
+	} else if id == 0 {
+		return copy(b, "und")
+	}
+	l := lang[id<<2:]
+	if l[3] == 0 {
+		return copy(b, l[:3])
+	}
+	return copy(b, l[:2])
+}
+
+// String returns the BCP 47 representation of the langID.
+// Use b as variable name, instead of id, to ensure the variable
+// used is consistent with that of Base in which this type is embedded.
+func (b Language) String() string {
+	if b == 0 {
+		return "und"
+	} else if b >= langNoIndexOffset {
+		b -= langNoIndexOffset
+		buf := [3]byte{}
+		intToStr(uint(b), buf[:])
+		return string(buf[:])
+	}
+	l := lang.Elem(int(b))
+	if l[3] == 0 {
+		return l[:3]
+	}
+	return l[:2]
+}
+
+// ISO3 returns the ISO 639-3 language code.
+func (b Language) ISO3() string {
+	if b == 0 || b >= langNoIndexOffset {
+		return b.String()
+	}
+	l := lang.Elem(int(b))
+	if l[3] == 0 {
+		return l[:3]
+	} else if l[2] == 0 {
+		return altLangISO3.Elem(int(l[3]))[:3]
+	}
+	// This allocation will only happen for 3-letter ISO codes
+	// that are non-canonical BCP 47 language identifiers.
+	return l[0:1] + l[2:4]
+}
+
+// IsPrivateUse reports whether this language code is reserved for private use.
+func (b Language) IsPrivateUse() bool {
+	return langPrivateStart <= b && b <= langPrivateEnd
+}
+
+// SuppressScript returns the script marked as SuppressScript in the IANA
+// language tag repository, or 0 if there is no such script.
+func (b Language) SuppressScript() Script {
+	if b < langNoIndexOffset {
+		return Script(suppressScript[b])
+	}
+	return 0
+}
+
+type Region uint16
+
+// getRegionID returns the region id for s if s is a valid 2-letter region code
+// or unknownRegion.
+func getRegionID(s []byte) (Region, error) {
+	if len(s) == 3 {
+		if isAlpha(s[0]) {
+			return getRegionISO3(s)
+		}
+		if i, err := strconv.ParseUint(string(s), 10, 10); err == nil {
+			return getRegionM49(int(i))
+		}
+	}
+	return getRegionISO2(s)
+}
+
+// getRegionISO2 returns the regionID for the given 2-letter ISO country code
+// or unknownRegion if this does not exist.
+func getRegionISO2(s []byte) (Region, error) {
+	i, err := findIndex(regionISO, s, "ZZ")
+	if err != nil {
+		return 0, err
+	}
+	return Region(i) + isoRegionOffset, nil
+}
+
+// getRegionISO3 returns the regionID for the given 3-letter ISO country code
+// or unknownRegion if this does not exist.
+func getRegionISO3(s []byte) (Region, error) {
+	if tag.FixCase("ZZZ", s) {
+		for i := regionISO.Index(s[:1]); i != -1; i = regionISO.Next(s[:1], i) {
+			if e := regionISO.Elem(i); e[2] == s[1] && e[3] == s[2] {
+				return Region(i) + isoRegionOffset, nil
+			}
+		}
+		for i := 0; i < len(altRegionISO3); i += 3 {
+			if tag.Compare(altRegionISO3[i:i+3], s) == 0 {
+				return Region(altRegionIDs[i/3]), nil
+			}
+		}
+		return 0, NewValueError(s)
+	}
+	return 0, ErrSyntax
+}
+
+func getRegionM49(n int) (Region, error) {
+	if 0 < n && n <= 999 {
+		const (
+			searchBits = 7
+			regionBits = 9
+			regionMask = 1<<regionBits - 1
+		)
+		idx := n >> searchBits
+		buf := fromM49[m49Index[idx]:m49Index[idx+1]]
+		val := uint16(n) << regionBits // we rely on bits shifting out
+		i := sort.Search(len(buf), func(i int) bool {
+			return buf[i] >= val
+		})
+		if r := fromM49[int(m49Index[idx])+i]; r&^regionMask == val {
+			return Region(r & regionMask), nil
+		}
+	}
+	var e ValueError
+	fmt.Fprint(bytes.NewBuffer([]byte(e.v[:])), n)
+	return 0, e
+}
+
+// normRegion returns a region if r is deprecated or 0 otherwise.
+// TODO: consider supporting BYS (-> BLR), CSK (-> 200 or CZ), PHI (-> PHL) and AFI (-> DJ).
+// TODO: consider mapping split up regions to new most populous one (like CLDR).
+func normRegion(r Region) Region {
+	m := regionOldMap
+	k := sort.Search(len(m), func(i int) bool {
+		return m[i].From >= uint16(r)
+	})
+	if k < len(m) && m[k].From == uint16(r) {
+		return Region(m[k].To)
+	}
+	return 0
+}
+
+const (
+	iso3166UserAssigned = 1 << iota
+	ccTLD
+	bcp47Region
+)
+
+func (r Region) typ() byte {
+	return regionTypes[r]
+}
+
+// String returns the BCP 47 representation for the region.
+// It returns "ZZ" for an unspecified region.
+func (r Region) String() string {
+	if r < isoRegionOffset {
+		if r == 0 {
+			return "ZZ"
+		}
+		return fmt.Sprintf("%03d", r.M49())
+	}
+	r -= isoRegionOffset
+	return regionISO.Elem(int(r))[:2]
+}
+
+// ISO3 returns the 3-letter ISO code of r.
+// Note that not all regions have a 3-letter ISO code.
+// In such cases this method returns "ZZZ".
+func (r Region) ISO3() string {
+	if r < isoRegionOffset {
+		return "ZZZ"
+	}
+	r -= isoRegionOffset
+	reg := regionISO.Elem(int(r))
+	switch reg[2] {
+	case 0:
+		return altRegionISO3[reg[3]:][:3]
+	case ' ':
+		return "ZZZ"
+	}
+	return reg[0:1] + reg[2:4]
+}
+
+// M49 returns the UN M.49 encoding of r, or 0 if this encoding
+// is not defined for r.
+func (r Region) M49() int {
+	return int(m49[r])
+}
+
+// IsPrivateUse reports whether r has the ISO 3166 User-assigned status. This
+// may include private-use tags that are assigned by CLDR and used in this
+// implementation. So IsPrivateUse and IsCountry can be simultaneously true.
+func (r Region) IsPrivateUse() bool {
+	return r.typ()&iso3166UserAssigned != 0
+}
+
+type Script uint16
+
+// getScriptID returns the script id for string s. It assumes that s
+// is of the format [A-Z][a-z]{3}.
+func getScriptID(idx tag.Index, s []byte) (Script, error) {
+	i, err := findIndex(idx, s, "Zzzz")
+	return Script(i), err
+}
+
+// String returns the script code in title case.
+// It returns "Zzzz" for an unspecified script.
+func (s Script) String() string {
+	if s == 0 {
+		return "Zzzz"
+	}
+	return script.Elem(int(s))
+}
+
+// IsPrivateUse reports whether this script code is reserved for private use.
+func (s Script) IsPrivateUse() bool {
+	return _Qaaa <= s && s <= _Qabx
+}
+
+const (
+	maxAltTaglen = len("en-US-POSIX")
+	maxLen       = maxAltTaglen
+)
+
+var (
+	// grandfatheredMap holds a mapping from legacy and grandfathered tags to
+	// their base language or index to more elaborate tag.
+	grandfatheredMap = map[[maxLen]byte]int16{
+		[maxLen]byte{'a', 'r', 't', '-', 'l', 'o', 'j', 'b', 'a', 'n'}: _jbo, // art-lojban
+		[maxLen]byte{'i', '-', 'a', 'm', 'i'}:                          _ami, // i-ami
+		[maxLen]byte{'i', '-', 'b', 'n', 'n'}:                          _bnn, // i-bnn
+		[maxLen]byte{'i', '-', 'h', 'a', 'k'}:                          _hak, // i-hak
+		[maxLen]byte{'i', '-', 'k', 'l', 'i', 'n', 'g', 'o', 'n'}:      _tlh, // i-klingon
+		[maxLen]byte{'i', '-', 'l', 'u', 'x'}:                          _lb,  // i-lux
+		[maxLen]byte{'i', '-', 'n', 'a', 'v', 'a', 'j', 'o'}:           _nv,  // i-navajo
+		[maxLen]byte{'i', '-', 'p', 'w', 'n'}:                          _pwn, // i-pwn
+		[maxLen]byte{'i', '-', 't', 'a', 'o'}:                          _tao, // i-tao
+		[maxLen]byte{'i', '-', 't', 'a', 'y'}:                          _tay, // i-tay
+		[maxLen]byte{'i', '-', 't', 's', 'u'}:                          _tsu, // i-tsu
+		[maxLen]byte{'n', 'o', '-', 'b', 'o', 'k'}:                     _nb,  // no-bok
+		[maxLen]byte{'n', 'o', '-', 'n', 'y', 'n'}:                     _nn,  // no-nyn
+		[maxLen]byte{'s', 'g', 'n', '-', 'b', 'e', '-', 'f', 'r'}:      _sfb, // sgn-BE-FR
+		[maxLen]byte{'s', 'g', 'n', '-', 'b', 'e', '-', 'n', 'l'}:      _vgt, // sgn-BE-NL
+		[maxLen]byte{'s', 'g', 'n', '-', 'c', 'h', '-', 'd', 'e'}:      _sgg, // sgn-CH-DE
+		[maxLen]byte{'z', 'h', '-', 'g', 'u', 'o', 'y', 'u'}:           _cmn, // zh-guoyu
+		[maxLen]byte{'z', 'h', '-', 'h', 'a', 'k', 'k', 'a'}:           _hak, // zh-hakka
+		[maxLen]byte{'z', 'h', '-', 'm', 'i', 'n', '-', 'n', 'a', 'n'}: _nan, // zh-min-nan
+		[maxLen]byte{'z', 'h', '-', 'x', 'i', 'a', 'n', 'g'}:           _hsn, // zh-xiang
+
+		// Grandfathered tags with no modern replacement will be converted as
+		// follows:
+		[maxLen]byte{'c', 'e', 'l', '-', 'g', 'a', 'u', 'l', 'i', 's', 'h'}: -1, // cel-gaulish
+		[maxLen]byte{'e', 'n', '-', 'g', 'b', '-', 'o', 'e', 'd'}:           -2, // en-GB-oed
+		[maxLen]byte{'i', '-', 'd', 'e', 'f', 'a', 'u', 'l', 't'}:           -3, // i-default
+		[maxLen]byte{'i', '-', 'e', 'n', 'o', 'c', 'h', 'i', 'a', 'n'}:      -4, // i-enochian
+		[maxLen]byte{'i', '-', 'm', 'i', 'n', 'g', 'o'}:                     -5, // i-mingo
+		[maxLen]byte{'z', 'h', '-', 'm', 'i', 'n'}:                          -6, // zh-min
+
+		// CLDR-specific tag.
+		[maxLen]byte{'r', 'o', 'o', 't'}:                                    0,  // root
+		[maxLen]byte{'e', 'n', '-', 'u', 's', '-', 'p', 'o', 's', 'i', 'x'}: -7, // en_US_POSIX"
+	}
+
+	altTagIndex = [...]uint8{0, 17, 31, 45, 61, 74, 86, 102}
+
+	altTags = "xtg-x-cel-gaulishen-GB-oxendicten-x-i-defaultund-x-i-enochiansee-x-i-mingonan-x-zh-minen-US-u-va-posix"
+)
+
+func grandfathered(s [maxAltTaglen]byte) (t Tag, ok bool) {
+	if v, ok := grandfatheredMap[s]; ok {
+		if v < 0 {
+			return Make(altTags[altTagIndex[-v-1]:altTagIndex[-v]]), true
+		}
+		t.LangID = Language(v)
+		return t, true
+	}
+	return t, false
+}
diff --git a/vendor/golang.org/x/text/internal/language/match.go b/vendor/golang.org/x/text/internal/language/match.go
new file mode 100644
index 00000000000..75a2dbca764
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/match.go
@@ -0,0 +1,226 @@
+// 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 language
+
+import "errors"
+
+type scriptRegionFlags uint8
+
+const (
+	isList = 1 << iota
+	scriptInFrom
+	regionInFrom
+)
+
+func (t *Tag) setUndefinedLang(id Language) {
+	if t.LangID == 0 {
+		t.LangID = id
+	}
+}
+
+func (t *Tag) setUndefinedScript(id Script) {
+	if t.ScriptID == 0 {
+		t.ScriptID = id
+	}
+}
+
+func (t *Tag) setUndefinedRegion(id Region) {
+	if t.RegionID == 0 || t.RegionID.Contains(id) {
+		t.RegionID = id
+	}
+}
+
+// ErrMissingLikelyTagsData indicates no information was available
+// to compute likely values of missing tags.
+var ErrMissingLikelyTagsData = errors.New("missing likely tags data")
+
+// addLikelySubtags sets subtags to their most likely value, given the locale.
+// In most cases this means setting fields for unknown values, but in some
+// cases it may alter a value.  It returns an ErrMissingLikelyTagsData error
+// if the given locale cannot be expanded.
+func (t Tag) addLikelySubtags() (Tag, error) {
+	id, err := addTags(t)
+	if err != nil {
+		return t, err
+	} else if id.equalTags(t) {
+		return t, nil
+	}
+	id.RemakeString()
+	return id, nil
+}
+
+// specializeRegion attempts to specialize a group region.
+func specializeRegion(t *Tag) bool {
+	if i := regionInclusion[t.RegionID]; i < nRegionGroups {
+		x := likelyRegionGroup[i]
+		if Language(x.lang) == t.LangID && Script(x.script) == t.ScriptID {
+			t.RegionID = Region(x.region)
+		}
+		return true
+	}
+	return false
+}
+
+// Maximize returns a new tag with missing tags filled in.
+func (t Tag) Maximize() (Tag, error) {
+	return addTags(t)
+}
+
+func addTags(t Tag) (Tag, error) {
+	// We leave private use identifiers alone.
+	if t.IsPrivateUse() {
+		return t, nil
+	}
+	if t.ScriptID != 0 && t.RegionID != 0 {
+		if t.LangID != 0 {
+			// already fully specified
+			specializeRegion(&t)
+			return t, nil
+		}
+		// Search matches for und-script-region. Note that for these cases
+		// region will never be a group so there is no need to check for this.
+		list := likelyRegion[t.RegionID : t.RegionID+1]
+		if x := list[0]; x.flags&isList != 0 {
+			list = likelyRegionList[x.lang : x.lang+uint16(x.script)]
+		}
+		for _, x := range list {
+			// Deviating from the spec. See match_test.go for details.
+			if Script(x.script) == t.ScriptID {
+				t.setUndefinedLang(Language(x.lang))
+				return t, nil
+			}
+		}
+	}
+	if t.LangID != 0 {
+		// Search matches for lang-script and lang-region, where lang != und.
+		if t.LangID < langNoIndexOffset {
+			x := likelyLang[t.LangID]
+			if x.flags&isList != 0 {
+				list := likelyLangList[x.region : x.region+uint16(x.script)]
+				if t.ScriptID != 0 {
+					for _, x := range list {
+						if Script(x.script) == t.ScriptID && x.flags&scriptInFrom != 0 {
+							t.setUndefinedRegion(Region(x.region))
+							return t, nil
+						}
+					}
+				} else if t.RegionID != 0 {
+					count := 0
+					goodScript := true
+					tt := t
+					for _, x := range list {
+						// We visit all entries for which the script was not
+						// defined, including the ones where the region was not
+						// defined. This allows for proper disambiguation within
+						// regions.
+						if x.flags&scriptInFrom == 0 && t.RegionID.Contains(Region(x.region)) {
+							tt.RegionID = Region(x.region)
+							tt.setUndefinedScript(Script(x.script))
+							goodScript = goodScript && tt.ScriptID == Script(x.script)
+							count++
+						}
+					}
+					if count == 1 {
+						return tt, nil
+					}
+					// Even if we fail to find a unique Region, we might have
+					// an unambiguous script.
+					if goodScript {
+						t.ScriptID = tt.ScriptID
+					}
+				}
+			}
+		}
+	} else {
+		// Search matches for und-script.
+		if t.ScriptID != 0 {
+			x := likelyScript[t.ScriptID]
+			if x.region != 0 {
+				t.setUndefinedRegion(Region(x.region))
+				t.setUndefinedLang(Language(x.lang))
+				return t, nil
+			}
+		}
+		// Search matches for und-region. If und-script-region exists, it would
+		// have been found earlier.
+		if t.RegionID != 0 {
+			if i := regionInclusion[t.RegionID]; i < nRegionGroups {
+				x := likelyRegionGroup[i]
+				if x.region != 0 {
+					t.setUndefinedLang(Language(x.lang))
+					t.setUndefinedScript(Script(x.script))
+					t.RegionID = Region(x.region)
+				}
+			} else {
+				x := likelyRegion[t.RegionID]
+				if x.flags&isList != 0 {
+					x = likelyRegionList[x.lang]
+				}
+				if x.script != 0 && x.flags != scriptInFrom {
+					t.setUndefinedLang(Language(x.lang))
+					t.setUndefinedScript(Script(x.script))
+					return t, nil
+				}
+			}
+		}
+	}
+
+	// Search matches for lang.
+	if t.LangID < langNoIndexOffset {
+		x := likelyLang[t.LangID]
+		if x.flags&isList != 0 {
+			x = likelyLangList[x.region]
+		}
+		if x.region != 0 {
+			t.setUndefinedScript(Script(x.script))
+			t.setUndefinedRegion(Region(x.region))
+		}
+		specializeRegion(&t)
+		if t.LangID == 0 {
+			t.LangID = _en // default language
+		}
+		return t, nil
+	}
+	return t, ErrMissingLikelyTagsData
+}
+
+func (t *Tag) setTagsFrom(id Tag) {
+	t.LangID = id.LangID
+	t.ScriptID = id.ScriptID
+	t.RegionID = id.RegionID
+}
+
+// minimize removes the region or script subtags from t such that
+// t.addLikelySubtags() == t.minimize().addLikelySubtags().
+func (t Tag) minimize() (Tag, error) {
+	t, err := minimizeTags(t)
+	if err != nil {
+		return t, err
+	}
+	t.RemakeString()
+	return t, nil
+}
+
+// minimizeTags mimics the behavior of the ICU 51 C implementation.
+func minimizeTags(t Tag) (Tag, error) {
+	if t.equalTags(Und) {
+		return t, nil
+	}
+	max, err := addTags(t)
+	if err != nil {
+		return t, err
+	}
+	for _, id := range [...]Tag{
+		{LangID: t.LangID},
+		{LangID: t.LangID, RegionID: t.RegionID},
+		{LangID: t.LangID, ScriptID: t.ScriptID},
+	} {
+		if x, err := addTags(id); err == nil && max.equalTags(x) {
+			t.setTagsFrom(id)
+			break
+		}
+	}
+	return t, nil
+}
diff --git a/vendor/golang.org/x/text/internal/language/parse.go b/vendor/golang.org/x/text/internal/language/parse.go
new file mode 100644
index 00000000000..aad1e0acf77
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/parse.go
@@ -0,0 +1,608 @@
+// 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 language
+
+import (
+	"bytes"
+	"errors"
+	"fmt"
+	"sort"
+
+	"golang.org/x/text/internal/tag"
+)
+
+// isAlpha returns true if the byte is not a digit.
+// b must be an ASCII letter or digit.
+func isAlpha(b byte) bool {
+	return b > '9'
+}
+
+// isAlphaNum returns true if the string contains only ASCII letters or digits.
+func isAlphaNum(s []byte) bool {
+	for _, c := range s {
+		if !('a' <= c && c <= 'z' || 'A' <= c && c <= 'Z' || '0' <= c && c <= '9') {
+			return false
+		}
+	}
+	return true
+}
+
+// ErrSyntax is returned by any of the parsing functions when the
+// input is not well-formed, according to BCP 47.
+// TODO: return the position at which the syntax error occurred?
+var ErrSyntax = errors.New("language: tag is not well-formed")
+
+// ErrDuplicateKey is returned when a tag contains the same key twice with
+// different values in the -u section.
+var ErrDuplicateKey = errors.New("language: different values for same key in -u extension")
+
+// ValueError is returned by any of the parsing functions when the
+// input is well-formed but the respective subtag is not recognized
+// as a valid value.
+type ValueError struct {
+	v [8]byte
+}
+
+// NewValueError creates a new ValueError.
+func NewValueError(tag []byte) ValueError {
+	var e ValueError
+	copy(e.v[:], tag)
+	return e
+}
+
+func (e ValueError) tag() []byte {
+	n := bytes.IndexByte(e.v[:], 0)
+	if n == -1 {
+		n = 8
+	}
+	return e.v[:n]
+}
+
+// Error implements the error interface.
+func (e ValueError) Error() string {
+	return fmt.Sprintf("language: subtag %q is well-formed but unknown", e.tag())
+}
+
+// Subtag returns the subtag for which the error occurred.
+func (e ValueError) Subtag() string {
+	return string(e.tag())
+}
+
+// scanner is used to scan BCP 47 tokens, which are separated by _ or -.
+type scanner struct {
+	b     []byte
+	bytes [max99thPercentileSize]byte
+	token []byte
+	start int // start position of the current token
+	end   int // end position of the current token
+	next  int // next point for scan
+	err   error
+	done  bool
+}
+
+func makeScannerString(s string) scanner {
+	scan := scanner{}
+	if len(s) <= len(scan.bytes) {
+		scan.b = scan.bytes[:copy(scan.bytes[:], s)]
+	} else {
+		scan.b = []byte(s)
+	}
+	scan.init()
+	return scan
+}
+
+// makeScanner returns a scanner using b as the input buffer.
+// b is not copied and may be modified by the scanner routines.
+func makeScanner(b []byte) scanner {
+	scan := scanner{b: b}
+	scan.init()
+	return scan
+}
+
+func (s *scanner) init() {
+	for i, c := range s.b {
+		if c == '_' {
+			s.b[i] = '-'
+		}
+	}
+	s.scan()
+}
+
+// restToLower converts the string between start and end to lower case.
+func (s *scanner) toLower(start, end int) {
+	for i := start; i < end; i++ {
+		c := s.b[i]
+		if 'A' <= c && c <= 'Z' {
+			s.b[i] += 'a' - 'A'
+		}
+	}
+}
+
+func (s *scanner) setError(e error) {
+	if s.err == nil || (e == ErrSyntax && s.err != ErrSyntax) {
+		s.err = e
+	}
+}
+
+// resizeRange shrinks or grows the array at position oldStart such that
+// a new string of size newSize can fit between oldStart and oldEnd.
+// Sets the scan point to after the resized range.
+func (s *scanner) resizeRange(oldStart, oldEnd, newSize int) {
+	s.start = oldStart
+	if end := oldStart + newSize; end != oldEnd {
+		diff := end - oldEnd
+		var b []byte
+		if n := len(s.b) + diff; n > cap(s.b) {
+			b = make([]byte, n)
+			copy(b, s.b[:oldStart])
+		} else {
+			b = s.b[:n]
+		}
+		copy(b[end:], s.b[oldEnd:])
+		s.b = b
+		s.next = end + (s.next - s.end)
+		s.end = end
+	}
+}
+
+// replace replaces the current token with repl.
+func (s *scanner) replace(repl string) {
+	s.resizeRange(s.start, s.end, len(repl))
+	copy(s.b[s.start:], repl)
+}
+
+// gobble removes the current token from the input.
+// Caller must call scan after calling gobble.
+func (s *scanner) gobble(e error) {
+	s.setError(e)
+	if s.start == 0 {
+		s.b = s.b[:+copy(s.b, s.b[s.next:])]
+		s.end = 0
+	} else {
+		s.b = s.b[:s.start-1+copy(s.b[s.start-1:], s.b[s.end:])]
+		s.end = s.start - 1
+	}
+	s.next = s.start
+}
+
+// deleteRange removes the given range from s.b before the current token.
+func (s *scanner) deleteRange(start, end int) {
+	s.b = s.b[:start+copy(s.b[start:], s.b[end:])]
+	diff := end - start
+	s.next -= diff
+	s.start -= diff
+	s.end -= diff
+}
+
+// scan parses the next token of a BCP 47 string.  Tokens that are larger
+// than 8 characters or include non-alphanumeric characters result in an error
+// and are gobbled and removed from the output.
+// It returns the end position of the last token consumed.
+func (s *scanner) scan() (end int) {
+	end = s.end
+	s.token = nil
+	for s.start = s.next; s.next < len(s.b); {
+		i := bytes.IndexByte(s.b[s.next:], '-')
+		if i == -1 {
+			s.end = len(s.b)
+			s.next = len(s.b)
+			i = s.end - s.start
+		} else {
+			s.end = s.next + i
+			s.next = s.end + 1
+		}
+		token := s.b[s.start:s.end]
+		if i < 1 || i > 8 || !isAlphaNum(token) {
+			s.gobble(ErrSyntax)
+			continue
+		}
+		s.token = token
+		return end
+	}
+	if n := len(s.b); n > 0 && s.b[n-1] == '-' {
+		s.setError(ErrSyntax)
+		s.b = s.b[:len(s.b)-1]
+	}
+	s.done = true
+	return end
+}
+
+// acceptMinSize parses multiple tokens of the given size or greater.
+// It returns the end position of the last token consumed.
+func (s *scanner) acceptMinSize(min int) (end int) {
+	end = s.end
+	s.scan()
+	for ; len(s.token) >= min; s.scan() {
+		end = s.end
+	}
+	return end
+}
+
+// Parse parses the given BCP 47 string and returns a valid Tag. If parsing
+// failed it returns an error and any part of the tag that could be parsed.
+// If parsing succeeded but an unknown value was found, it returns
+// ValueError. The Tag returned in this case is just stripped of the unknown
+// value. All other values are preserved. It accepts tags in the BCP 47 format
+// and extensions to this standard defined in
+// https://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers.
+func Parse(s string) (t Tag, err error) {
+	// TODO: consider supporting old-style locale key-value pairs.
+	if s == "" {
+		return Und, ErrSyntax
+	}
+	defer func() {
+		if recover() != nil {
+			t = Und
+			err = ErrSyntax
+			return
+		}
+	}()
+	if len(s) <= maxAltTaglen {
+		b := [maxAltTaglen]byte{}
+		for i, c := range s {
+			// Generating invalid UTF-8 is okay as it won't match.
+			if 'A' <= c && c <= 'Z' {
+				c += 'a' - 'A'
+			} else if c == '_' {
+				c = '-'
+			}
+			b[i] = byte(c)
+		}
+		if t, ok := grandfathered(b); ok {
+			return t, nil
+		}
+	}
+	scan := makeScannerString(s)
+	return parse(&scan, s)
+}
+
+func parse(scan *scanner, s string) (t Tag, err error) {
+	t = Und
+	var end int
+	if n := len(scan.token); n <= 1 {
+		scan.toLower(0, len(scan.b))
+		if n == 0 || scan.token[0] != 'x' {
+			return t, ErrSyntax
+		}
+		end = parseExtensions(scan)
+	} else if n >= 4 {
+		return Und, ErrSyntax
+	} else { // the usual case
+		t, end = parseTag(scan, true)
+		if n := len(scan.token); n == 1 {
+			t.pExt = uint16(end)
+			end = parseExtensions(scan)
+		} else if end < len(scan.b) {
+			scan.setError(ErrSyntax)
+			scan.b = scan.b[:end]
+		}
+	}
+	if int(t.pVariant) < len(scan.b) {
+		if end < len(s) {
+			s = s[:end]
+		}
+		if len(s) > 0 && tag.Compare(s, scan.b) == 0 {
+			t.str = s
+		} else {
+			t.str = string(scan.b)
+		}
+	} else {
+		t.pVariant, t.pExt = 0, 0
+	}
+	return t, scan.err
+}
+
+// parseTag parses language, script, region and variants.
+// It returns a Tag and the end position in the input that was parsed.
+// If doNorm is true, then <lang>-<extlang> will be normalized to <extlang>.
+func parseTag(scan *scanner, doNorm bool) (t Tag, end int) {
+	var e error
+	// TODO: set an error if an unknown lang, script or region is encountered.
+	t.LangID, e = getLangID(scan.token)
+	scan.setError(e)
+	scan.replace(t.LangID.String())
+	langStart := scan.start
+	end = scan.scan()
+	for len(scan.token) == 3 && isAlpha(scan.token[0]) {
+		// From http://tools.ietf.org/html/bcp47, <lang>-<extlang> tags are equivalent
+		// to a tag of the form <extlang>.
+		if doNorm {
+			lang, e := getLangID(scan.token)
+			if lang != 0 {
+				t.LangID = lang
+				langStr := lang.String()
+				copy(scan.b[langStart:], langStr)
+				scan.b[langStart+len(langStr)] = '-'
+				scan.start = langStart + len(langStr) + 1
+			}
+			scan.gobble(e)
+		}
+		end = scan.scan()
+	}
+	if len(scan.token) == 4 && isAlpha(scan.token[0]) {
+		t.ScriptID, e = getScriptID(script, scan.token)
+		if t.ScriptID == 0 {
+			scan.gobble(e)
+		}
+		end = scan.scan()
+	}
+	if n := len(scan.token); n >= 2 && n <= 3 {
+		t.RegionID, e = getRegionID(scan.token)
+		if t.RegionID == 0 {
+			scan.gobble(e)
+		} else {
+			scan.replace(t.RegionID.String())
+		}
+		end = scan.scan()
+	}
+	scan.toLower(scan.start, len(scan.b))
+	t.pVariant = byte(end)
+	end = parseVariants(scan, end, t)
+	t.pExt = uint16(end)
+	return t, end
+}
+
+var separator = []byte{'-'}
+
+// parseVariants scans tokens as long as each token is a valid variant string.
+// Duplicate variants are removed.
+func parseVariants(scan *scanner, end int, t Tag) int {
+	start := scan.start
+	varIDBuf := [4]uint8{}
+	variantBuf := [4][]byte{}
+	varID := varIDBuf[:0]
+	variant := variantBuf[:0]
+	last := -1
+	needSort := false
+	for ; len(scan.token) >= 4; scan.scan() {
+		// TODO: measure the impact of needing this conversion and redesign
+		// the data structure if there is an issue.
+		v, ok := variantIndex[string(scan.token)]
+		if !ok {
+			// unknown variant
+			// TODO: allow user-defined variants?
+			scan.gobble(NewValueError(scan.token))
+			continue
+		}
+		varID = append(varID, v)
+		variant = append(variant, scan.token)
+		if !needSort {
+			if last < int(v) {
+				last = int(v)
+			} else {
+				needSort = true
+				// There is no legal combinations of more than 7 variants
+				// (and this is by no means a useful sequence).
+				const maxVariants = 8
+				if len(varID) > maxVariants {
+					break
+				}
+			}
+		}
+		end = scan.end
+	}
+	if needSort {
+		sort.Sort(variantsSort{varID, variant})
+		k, l := 0, -1
+		for i, v := range varID {
+			w := int(v)
+			if l == w {
+				// Remove duplicates.
+				continue
+			}
+			varID[k] = varID[i]
+			variant[k] = variant[i]
+			k++
+			l = w
+		}
+		if str := bytes.Join(variant[:k], separator); len(str) == 0 {
+			end = start - 1
+		} else {
+			scan.resizeRange(start, end, len(str))
+			copy(scan.b[scan.start:], str)
+			end = scan.end
+		}
+	}
+	return end
+}
+
+type variantsSort struct {
+	i []uint8
+	v [][]byte
+}
+
+func (s variantsSort) Len() int {
+	return len(s.i)
+}
+
+func (s variantsSort) Swap(i, j int) {
+	s.i[i], s.i[j] = s.i[j], s.i[i]
+	s.v[i], s.v[j] = s.v[j], s.v[i]
+}
+
+func (s variantsSort) Less(i, j int) bool {
+	return s.i[i] < s.i[j]
+}
+
+type bytesSort struct {
+	b [][]byte
+	n int // first n bytes to compare
+}
+
+func (b bytesSort) Len() int {
+	return len(b.b)
+}
+
+func (b bytesSort) Swap(i, j int) {
+	b.b[i], b.b[j] = b.b[j], b.b[i]
+}
+
+func (b bytesSort) Less(i, j int) bool {
+	for k := 0; k < b.n; k++ {
+		if b.b[i][k] == b.b[j][k] {
+			continue
+		}
+		return b.b[i][k] < b.b[j][k]
+	}
+	return false
+}
+
+// parseExtensions parses and normalizes the extensions in the buffer.
+// It returns the last position of scan.b that is part of any extension.
+// It also trims scan.b to remove excess parts accordingly.
+func parseExtensions(scan *scanner) int {
+	start := scan.start
+	exts := [][]byte{}
+	private := []byte{}
+	end := scan.end
+	for len(scan.token) == 1 {
+		extStart := scan.start
+		ext := scan.token[0]
+		end = parseExtension(scan)
+		extension := scan.b[extStart:end]
+		if len(extension) < 3 || (ext != 'x' && len(extension) < 4) {
+			scan.setError(ErrSyntax)
+			end = extStart
+			continue
+		} else if start == extStart && (ext == 'x' || scan.start == len(scan.b)) {
+			scan.b = scan.b[:end]
+			return end
+		} else if ext == 'x' {
+			private = extension
+			break
+		}
+		exts = append(exts, extension)
+	}
+	sort.Sort(bytesSort{exts, 1})
+	if len(private) > 0 {
+		exts = append(exts, private)
+	}
+	scan.b = scan.b[:start]
+	if len(exts) > 0 {
+		scan.b = append(scan.b, bytes.Join(exts, separator)...)
+	} else if start > 0 {
+		// Strip trailing '-'.
+		scan.b = scan.b[:start-1]
+	}
+	return end
+}
+
+// parseExtension parses a single extension and returns the position of
+// the extension end.
+func parseExtension(scan *scanner) int {
+	start, end := scan.start, scan.end
+	switch scan.token[0] {
+	case 'u': // https://www.ietf.org/rfc/rfc6067.txt
+		attrStart := end
+		scan.scan()
+		for last := []byte{}; len(scan.token) > 2; scan.scan() {
+			if bytes.Compare(scan.token, last) != -1 {
+				// Attributes are unsorted. Start over from scratch.
+				p := attrStart + 1
+				scan.next = p
+				attrs := [][]byte{}
+				for scan.scan(); len(scan.token) > 2; scan.scan() {
+					attrs = append(attrs, scan.token)
+					end = scan.end
+				}
+				sort.Sort(bytesSort{attrs, 3})
+				copy(scan.b[p:], bytes.Join(attrs, separator))
+				break
+			}
+			last = scan.token
+			end = scan.end
+		}
+		// Scan key-type sequences. A key is of length 2 and may be followed
+		// by 0 or more "type" subtags from 3 to the maximum of 8 letters.
+		var last, key []byte
+		for attrEnd := end; len(scan.token) == 2; last = key {
+			key = scan.token
+			end = scan.end
+			for scan.scan(); end < scan.end && len(scan.token) > 2; scan.scan() {
+				end = scan.end
+			}
+			// TODO: check key value validity
+			if bytes.Compare(key, last) != 1 || scan.err != nil {
+				// We have an invalid key or the keys are not sorted.
+				// Start scanning keys from scratch and reorder.
+				p := attrEnd + 1
+				scan.next = p
+				keys := [][]byte{}
+				for scan.scan(); len(scan.token) == 2; {
+					keyStart := scan.start
+					end = scan.end
+					for scan.scan(); end < scan.end && len(scan.token) > 2; scan.scan() {
+						end = scan.end
+					}
+					keys = append(keys, scan.b[keyStart:end])
+				}
+				sort.Stable(bytesSort{keys, 2})
+				if n := len(keys); n > 0 {
+					k := 0
+					for i := 1; i < n; i++ {
+						if !bytes.Equal(keys[k][:2], keys[i][:2]) {
+							k++
+							keys[k] = keys[i]
+						} else if !bytes.Equal(keys[k], keys[i]) {
+							scan.setError(ErrDuplicateKey)
+						}
+					}
+					keys = keys[:k+1]
+				}
+				reordered := bytes.Join(keys, separator)
+				if e := p + len(reordered); e < end {
+					scan.deleteRange(e, end)
+					end = e
+				}
+				copy(scan.b[p:], reordered)
+				break
+			}
+		}
+	case 't': // https://www.ietf.org/rfc/rfc6497.txt
+		scan.scan()
+		if n := len(scan.token); n >= 2 && n <= 3 && isAlpha(scan.token[1]) {
+			_, end = parseTag(scan, false)
+			scan.toLower(start, end)
+		}
+		for len(scan.token) == 2 && !isAlpha(scan.token[1]) {
+			end = scan.acceptMinSize(3)
+		}
+	case 'x':
+		end = scan.acceptMinSize(1)
+	default:
+		end = scan.acceptMinSize(2)
+	}
+	return end
+}
+
+// getExtension returns the name, body and end position of the extension.
+func getExtension(s string, p int) (end int, ext string) {
+	if s[p] == '-' {
+		p++
+	}
+	if s[p] == 'x' {
+		return len(s), s[p:]
+	}
+	end = nextExtension(s, p)
+	return end, s[p:end]
+}
+
+// nextExtension finds the next extension within the string, searching
+// for the -<char>- pattern from position p.
+// In the fast majority of cases, language tags will have at most
+// one extension and extensions tend to be small.
+func nextExtension(s string, p int) int {
+	for n := len(s) - 3; p < n; {
+		if s[p] == '-' {
+			if s[p+2] == '-' {
+				return p
+			}
+			p += 3
+		} else {
+			p++
+		}
+	}
+	return len(s)
+}
diff --git a/vendor/golang.org/x/text/internal/language/tables.go b/vendor/golang.org/x/text/internal/language/tables.go
new file mode 100644
index 00000000000..14167e74e40
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/tables.go
@@ -0,0 +1,3494 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+package language
+
+import "golang.org/x/text/internal/tag"
+
+// CLDRVersion is the CLDR version from which the tables in this package are derived.
+const CLDRVersion = "32"
+
+const NumLanguages = 8798
+
+const NumScripts = 261
+
+const NumRegions = 358
+
+type FromTo struct {
+	From uint16
+	To   uint16
+}
+
+const nonCanonicalUnd = 1201
+const (
+	_af  = 22
+	_am  = 39
+	_ar  = 58
+	_az  = 88
+	_bg  = 126
+	_bn  = 165
+	_ca  = 215
+	_cs  = 250
+	_da  = 257
+	_de  = 269
+	_el  = 310
+	_en  = 313
+	_es  = 318
+	_et  = 320
+	_fa  = 328
+	_fi  = 337
+	_fil = 339
+	_fr  = 350
+	_gu  = 420
+	_he  = 444
+	_hi  = 446
+	_hr  = 465
+	_hu  = 469
+	_hy  = 471
+	_id  = 481
+	_is  = 504
+	_it  = 505
+	_ja  = 512
+	_ka  = 528
+	_kk  = 578
+	_km  = 586
+	_kn  = 593
+	_ko  = 596
+	_ky  = 650
+	_lo  = 696
+	_lt  = 704
+	_lv  = 711
+	_mk  = 767
+	_ml  = 772
+	_mn  = 779
+	_mo  = 784
+	_mr  = 795
+	_ms  = 799
+	_mul = 806
+	_my  = 817
+	_nb  = 839
+	_ne  = 849
+	_nl  = 871
+	_no  = 879
+	_pa  = 925
+	_pl  = 947
+	_pt  = 960
+	_ro  = 988
+	_ru  = 994
+	_sh  = 1031
+	_si  = 1036
+	_sk  = 1042
+	_sl  = 1046
+	_sq  = 1073
+	_sr  = 1074
+	_sv  = 1092
+	_sw  = 1093
+	_ta  = 1104
+	_te  = 1121
+	_th  = 1131
+	_tl  = 1146
+	_tn  = 1152
+	_tr  = 1162
+	_uk  = 1198
+	_ur  = 1204
+	_uz  = 1212
+	_vi  = 1219
+	_zh  = 1321
+	_zu  = 1327
+	_jbo = 515
+	_ami = 1650
+	_bnn = 2357
+	_hak = 438
+	_tlh = 14467
+	_lb  = 661
+	_nv  = 899
+	_pwn = 12055
+	_tao = 14188
+	_tay = 14198
+	_tsu = 14662
+	_nn  = 874
+	_sfb = 13629
+	_vgt = 15701
+	_sgg = 13660
+	_cmn = 3007
+	_nan = 835
+	_hsn = 467
+)
+
+const langPrivateStart = 0x2f72
+
+const langPrivateEnd = 0x3179
+
+// lang holds an alphabetically sorted list of ISO-639 language identifiers.
+// All entries are 4 bytes. The index of the identifier (divided by 4) is the language tag.
+// For 2-byte language identifiers, the two successive bytes have the following meaning:
+//   - if the first letter of the 2- and 3-letter ISO codes are the same:
+//     the second and third letter of the 3-letter ISO code.
+//   - otherwise: a 0 and a by 2 bits right-shifted index into altLangISO3.
+//
+// For 3-byte language identifiers the 4th byte is 0.
+const lang tag.Index = "" + // Size: 5324 bytes
+	"---\x00aaaraai\x00aak\x00aau\x00abbkabi\x00abq\x00abr\x00abt\x00aby\x00a" +
+	"cd\x00ace\x00ach\x00ada\x00ade\x00adj\x00ady\x00adz\x00aeveaeb\x00aey" +
+	"\x00affragc\x00agd\x00agg\x00agm\x00ago\x00agq\x00aha\x00ahl\x00aho\x00a" +
+	"jg\x00akkaakk\x00ala\x00ali\x00aln\x00alt\x00ammhamm\x00amn\x00amo\x00am" +
+	"p\x00anrganc\x00ank\x00ann\x00any\x00aoj\x00aom\x00aoz\x00apc\x00apd\x00" +
+	"ape\x00apr\x00aps\x00apz\x00arraarc\x00arh\x00arn\x00aro\x00arq\x00ars" +
+	"\x00ary\x00arz\x00assmasa\x00ase\x00asg\x00aso\x00ast\x00ata\x00atg\x00a" +
+	"tj\x00auy\x00avvaavl\x00avn\x00avt\x00avu\x00awa\x00awb\x00awo\x00awx" +
+	"\x00ayymayb\x00azzebaakbal\x00ban\x00bap\x00bar\x00bas\x00bav\x00bax\x00" +
+	"bba\x00bbb\x00bbc\x00bbd\x00bbj\x00bbp\x00bbr\x00bcf\x00bch\x00bci\x00bc" +
+	"m\x00bcn\x00bco\x00bcq\x00bcu\x00bdd\x00beelbef\x00beh\x00bej\x00bem\x00" +
+	"bet\x00bew\x00bex\x00bez\x00bfd\x00bfq\x00bft\x00bfy\x00bgulbgc\x00bgn" +
+	"\x00bgx\x00bhihbhb\x00bhg\x00bhi\x00bhk\x00bhl\x00bho\x00bhy\x00biisbib" +
+	"\x00big\x00bik\x00bim\x00bin\x00bio\x00biq\x00bjh\x00bji\x00bjj\x00bjn" +
+	"\x00bjo\x00bjr\x00bjt\x00bjz\x00bkc\x00bkm\x00bkq\x00bku\x00bkv\x00blt" +
+	"\x00bmambmh\x00bmk\x00bmq\x00bmu\x00bnenbng\x00bnm\x00bnp\x00boodboj\x00" +
+	"bom\x00bon\x00bpy\x00bqc\x00bqi\x00bqp\x00bqv\x00brrebra\x00brh\x00brx" +
+	"\x00brz\x00bsosbsj\x00bsq\x00bss\x00bst\x00bto\x00btt\x00btv\x00bua\x00b" +
+	"uc\x00bud\x00bug\x00buk\x00bum\x00buo\x00bus\x00buu\x00bvb\x00bwd\x00bwr" +
+	"\x00bxh\x00bye\x00byn\x00byr\x00bys\x00byv\x00byx\x00bza\x00bze\x00bzf" +
+	"\x00bzh\x00bzw\x00caatcan\x00cbj\x00cch\x00ccp\x00ceheceb\x00cfa\x00cgg" +
+	"\x00chhachk\x00chm\x00cho\x00chp\x00chr\x00cja\x00cjm\x00cjv\x00ckb\x00c" +
+	"kl\x00cko\x00cky\x00cla\x00cme\x00cmg\x00cooscop\x00cps\x00crrecrh\x00cr" +
+	"j\x00crk\x00crl\x00crm\x00crs\x00csescsb\x00csw\x00ctd\x00cuhucvhvcyymda" +
+	"andad\x00daf\x00dag\x00dah\x00dak\x00dar\x00dav\x00dbd\x00dbq\x00dcc\x00" +
+	"ddn\x00deeuded\x00den\x00dga\x00dgh\x00dgi\x00dgl\x00dgr\x00dgz\x00dia" +
+	"\x00dje\x00dnj\x00dob\x00doi\x00dop\x00dow\x00dri\x00drs\x00dsb\x00dtm" +
+	"\x00dtp\x00dts\x00dty\x00dua\x00duc\x00dud\x00dug\x00dvivdva\x00dww\x00d" +
+	"yo\x00dyu\x00dzzodzg\x00ebu\x00eeweefi\x00egl\x00egy\x00eka\x00eky\x00el" +
+	"llema\x00emi\x00enngenn\x00enq\x00eopoeri\x00es\x00\x05esu\x00etstetr" +
+	"\x00ett\x00etu\x00etx\x00euusewo\x00ext\x00faasfaa\x00fab\x00fag\x00fai" +
+	"\x00fan\x00ffulffi\x00ffm\x00fiinfia\x00fil\x00fit\x00fjijflr\x00fmp\x00" +
+	"foaofod\x00fon\x00for\x00fpe\x00fqs\x00frrafrc\x00frp\x00frr\x00frs\x00f" +
+	"ub\x00fud\x00fue\x00fuf\x00fuh\x00fuq\x00fur\x00fuv\x00fuy\x00fvr\x00fyr" +
+	"ygalegaa\x00gaf\x00gag\x00gah\x00gaj\x00gam\x00gan\x00gaw\x00gay\x00gba" +
+	"\x00gbf\x00gbm\x00gby\x00gbz\x00gcr\x00gdlagde\x00gdn\x00gdr\x00geb\x00g" +
+	"ej\x00gel\x00gez\x00gfk\x00ggn\x00ghs\x00gil\x00gim\x00gjk\x00gjn\x00gju" +
+	"\x00gkn\x00gkp\x00gllgglk\x00gmm\x00gmv\x00gnrngnd\x00gng\x00god\x00gof" +
+	"\x00goi\x00gom\x00gon\x00gor\x00gos\x00got\x00grb\x00grc\x00grt\x00grw" +
+	"\x00gsw\x00guujgub\x00guc\x00gud\x00gur\x00guw\x00gux\x00guz\x00gvlvgvf" +
+	"\x00gvr\x00gvs\x00gwc\x00gwi\x00gwt\x00gyi\x00haauhag\x00hak\x00ham\x00h" +
+	"aw\x00haz\x00hbb\x00hdy\x00heebhhy\x00hiinhia\x00hif\x00hig\x00hih\x00hi" +
+	"l\x00hla\x00hlu\x00hmd\x00hmt\x00hnd\x00hne\x00hnj\x00hnn\x00hno\x00homo" +
+	"hoc\x00hoj\x00hot\x00hrrvhsb\x00hsn\x00htathuunhui\x00hyyehzerianaian" +
+	"\x00iar\x00iba\x00ibb\x00iby\x00ica\x00ich\x00idndidd\x00idi\x00idu\x00i" +
+	"eleife\x00igboigb\x00ige\x00iiiiijj\x00ikpkikk\x00ikt\x00ikw\x00ikx\x00i" +
+	"lo\x00imo\x00inndinh\x00iodoiou\x00iri\x00isslittaiukuiw\x00\x03iwm\x00i" +
+	"ws\x00izh\x00izi\x00japnjab\x00jam\x00jbo\x00jbu\x00jen\x00jgk\x00jgo" +
+	"\x00ji\x00\x06jib\x00jmc\x00jml\x00jra\x00jut\x00jvavjwavkaatkaa\x00kab" +
+	"\x00kac\x00kad\x00kai\x00kaj\x00kam\x00kao\x00kbd\x00kbm\x00kbp\x00kbq" +
+	"\x00kbx\x00kby\x00kcg\x00kck\x00kcl\x00kct\x00kde\x00kdh\x00kdl\x00kdt" +
+	"\x00kea\x00ken\x00kez\x00kfo\x00kfr\x00kfy\x00kgonkge\x00kgf\x00kgp\x00k" +
+	"ha\x00khb\x00khn\x00khq\x00khs\x00kht\x00khw\x00khz\x00kiikkij\x00kiu" +
+	"\x00kiw\x00kjuakjd\x00kjg\x00kjs\x00kjy\x00kkazkkc\x00kkj\x00klalkln\x00" +
+	"klq\x00klt\x00klx\x00kmhmkmb\x00kmh\x00kmo\x00kms\x00kmu\x00kmw\x00knank" +
+	"nf\x00knp\x00koorkoi\x00kok\x00kol\x00kos\x00koz\x00kpe\x00kpf\x00kpo" +
+	"\x00kpr\x00kpx\x00kqb\x00kqf\x00kqs\x00kqy\x00kraukrc\x00kri\x00krj\x00k" +
+	"rl\x00krs\x00kru\x00ksasksb\x00ksd\x00ksf\x00ksh\x00ksj\x00ksr\x00ktb" +
+	"\x00ktm\x00kto\x00kuurkub\x00kud\x00kue\x00kuj\x00kum\x00kun\x00kup\x00k" +
+	"us\x00kvomkvg\x00kvr\x00kvx\x00kw\x00\x01kwj\x00kwo\x00kxa\x00kxc\x00kxm" +
+	"\x00kxp\x00kxw\x00kxz\x00kyirkye\x00kyx\x00kzr\x00laatlab\x00lad\x00lag" +
+	"\x00lah\x00laj\x00las\x00lbtzlbe\x00lbu\x00lbw\x00lcm\x00lcp\x00ldb\x00l" +
+	"ed\x00lee\x00lem\x00lep\x00leq\x00leu\x00lez\x00lguglgg\x00liimlia\x00li" +
+	"d\x00lif\x00lig\x00lih\x00lij\x00lis\x00ljp\x00lki\x00lkt\x00lle\x00lln" +
+	"\x00lmn\x00lmo\x00lmp\x00lninlns\x00lnu\x00loaoloj\x00lok\x00lol\x00lor" +
+	"\x00los\x00loz\x00lrc\x00ltitltg\x00luublua\x00luo\x00luy\x00luz\x00lvav" +
+	"lwl\x00lzh\x00lzz\x00mad\x00maf\x00mag\x00mai\x00mak\x00man\x00mas\x00ma" +
+	"w\x00maz\x00mbh\x00mbo\x00mbq\x00mbu\x00mbw\x00mci\x00mcp\x00mcq\x00mcr" +
+	"\x00mcu\x00mda\x00mde\x00mdf\x00mdh\x00mdj\x00mdr\x00mdx\x00med\x00mee" +
+	"\x00mek\x00men\x00mer\x00met\x00meu\x00mfa\x00mfe\x00mfn\x00mfo\x00mfq" +
+	"\x00mglgmgh\x00mgl\x00mgo\x00mgp\x00mgy\x00mhahmhi\x00mhl\x00mirimif\x00" +
+	"min\x00mis\x00miw\x00mkkdmki\x00mkl\x00mkp\x00mkw\x00mlalmle\x00mlp\x00m" +
+	"ls\x00mmo\x00mmu\x00mmx\x00mnonmna\x00mnf\x00mni\x00mnw\x00moolmoa\x00mo" +
+	"e\x00moh\x00mos\x00mox\x00mpp\x00mps\x00mpt\x00mpx\x00mql\x00mrarmrd\x00" +
+	"mrj\x00mro\x00mssamtltmtc\x00mtf\x00mti\x00mtr\x00mua\x00mul\x00mur\x00m" +
+	"us\x00mva\x00mvn\x00mvy\x00mwk\x00mwr\x00mwv\x00mxc\x00mxm\x00myyamyk" +
+	"\x00mym\x00myv\x00myw\x00myx\x00myz\x00mzk\x00mzm\x00mzn\x00mzp\x00mzw" +
+	"\x00mzz\x00naaunac\x00naf\x00nah\x00nak\x00nan\x00nap\x00naq\x00nas\x00n" +
+	"bobnca\x00nce\x00ncf\x00nch\x00nco\x00ncu\x00nddendc\x00nds\x00neepneb" +
+	"\x00new\x00nex\x00nfr\x00ngdonga\x00ngb\x00ngl\x00nhb\x00nhe\x00nhw\x00n" +
+	"if\x00nii\x00nij\x00nin\x00niu\x00niy\x00niz\x00njo\x00nkg\x00nko\x00nll" +
+	"dnmg\x00nmz\x00nnnonnf\x00nnh\x00nnk\x00nnm\x00noornod\x00noe\x00non\x00" +
+	"nop\x00nou\x00nqo\x00nrblnrb\x00nsk\x00nsn\x00nso\x00nss\x00ntm\x00ntr" +
+	"\x00nui\x00nup\x00nus\x00nuv\x00nux\x00nvavnwb\x00nxq\x00nxr\x00nyyanym" +
+	"\x00nyn\x00nzi\x00occiogc\x00ojjiokr\x00okv\x00omrmong\x00onn\x00ons\x00" +
+	"opm\x00orrioro\x00oru\x00osssosa\x00ota\x00otk\x00ozm\x00paanpag\x00pal" +
+	"\x00pam\x00pap\x00pau\x00pbi\x00pcd\x00pcm\x00pdc\x00pdt\x00ped\x00peo" +
+	"\x00pex\x00pfl\x00phl\x00phn\x00pilipil\x00pip\x00pka\x00pko\x00plolpla" +
+	"\x00pms\x00png\x00pnn\x00pnt\x00pon\x00ppo\x00pra\x00prd\x00prg\x00psusp" +
+	"ss\x00ptorptp\x00puu\x00pwa\x00quuequc\x00qug\x00rai\x00raj\x00rao\x00rc" +
+	"f\x00rej\x00rel\x00res\x00rgn\x00rhg\x00ria\x00rif\x00rjs\x00rkt\x00rmoh" +
+	"rmf\x00rmo\x00rmt\x00rmu\x00rnunrna\x00rng\x00roonrob\x00rof\x00roo\x00r" +
+	"ro\x00rtm\x00ruusrue\x00rug\x00rw\x00\x04rwk\x00rwo\x00ryu\x00saansaf" +
+	"\x00sah\x00saq\x00sas\x00sat\x00sav\x00saz\x00sba\x00sbe\x00sbp\x00scrds" +
+	"ck\x00scl\x00scn\x00sco\x00scs\x00sdndsdc\x00sdh\x00semesef\x00seh\x00se" +
+	"i\x00ses\x00sgagsga\x00sgs\x00sgw\x00sgz\x00sh\x00\x02shi\x00shk\x00shn" +
+	"\x00shu\x00siinsid\x00sig\x00sil\x00sim\x00sjr\x00sklkskc\x00skr\x00sks" +
+	"\x00sllvsld\x00sli\x00sll\x00sly\x00smmosma\x00smi\x00smj\x00smn\x00smp" +
+	"\x00smq\x00sms\x00snnasnc\x00snk\x00snp\x00snx\x00sny\x00soomsok\x00soq" +
+	"\x00sou\x00soy\x00spd\x00spl\x00sps\x00sqqisrrpsrb\x00srn\x00srr\x00srx" +
+	"\x00ssswssd\x00ssg\x00ssy\x00stotstk\x00stq\x00suunsua\x00sue\x00suk\x00" +
+	"sur\x00sus\x00svweswwaswb\x00swc\x00swg\x00swp\x00swv\x00sxn\x00sxw\x00s" +
+	"yl\x00syr\x00szl\x00taamtaj\x00tal\x00tan\x00taq\x00tbc\x00tbd\x00tbf" +
+	"\x00tbg\x00tbo\x00tbw\x00tbz\x00tci\x00tcy\x00tdd\x00tdg\x00tdh\x00teelt" +
+	"ed\x00tem\x00teo\x00tet\x00tfi\x00tggktgc\x00tgo\x00tgu\x00thhathl\x00th" +
+	"q\x00thr\x00tiirtif\x00tig\x00tik\x00tim\x00tio\x00tiv\x00tkuktkl\x00tkr" +
+	"\x00tkt\x00tlgltlf\x00tlx\x00tly\x00tmh\x00tmy\x00tnsntnh\x00toontof\x00" +
+	"tog\x00toq\x00tpi\x00tpm\x00tpz\x00tqo\x00trurtru\x00trv\x00trw\x00tssot" +
+	"sd\x00tsf\x00tsg\x00tsj\x00tsw\x00ttatttd\x00tte\x00ttj\x00ttr\x00tts" +
+	"\x00ttt\x00tuh\x00tul\x00tum\x00tuq\x00tvd\x00tvl\x00tvu\x00twwitwh\x00t" +
+	"wq\x00txg\x00tyahtya\x00tyv\x00tzm\x00ubu\x00udm\x00ugiguga\x00ukkruli" +
+	"\x00umb\x00und\x00unr\x00unx\x00urrduri\x00urt\x00urw\x00usa\x00utr\x00u" +
+	"vh\x00uvl\x00uzzbvag\x00vai\x00van\x00veenvec\x00vep\x00viievic\x00viv" +
+	"\x00vls\x00vmf\x00vmw\x00voolvot\x00vro\x00vun\x00vut\x00walnwae\x00waj" +
+	"\x00wal\x00wan\x00war\x00wbp\x00wbq\x00wbr\x00wci\x00wer\x00wgi\x00whg" +
+	"\x00wib\x00wiu\x00wiv\x00wja\x00wji\x00wls\x00wmo\x00wnc\x00wni\x00wnu" +
+	"\x00woolwob\x00wos\x00wrs\x00wsk\x00wtm\x00wuu\x00wuv\x00wwa\x00xav\x00x" +
+	"bi\x00xcr\x00xes\x00xhhoxla\x00xlc\x00xld\x00xmf\x00xmn\x00xmr\x00xna" +
+	"\x00xnr\x00xog\x00xon\x00xpr\x00xrb\x00xsa\x00xsi\x00xsm\x00xsr\x00xwe" +
+	"\x00yam\x00yao\x00yap\x00yas\x00yat\x00yav\x00yay\x00yaz\x00yba\x00ybb" +
+	"\x00yby\x00yer\x00ygr\x00ygw\x00yiidyko\x00yle\x00ylg\x00yll\x00yml\x00y" +
+	"ooryon\x00yrb\x00yre\x00yrl\x00yss\x00yua\x00yue\x00yuj\x00yut\x00yuw" +
+	"\x00zahazag\x00zbl\x00zdj\x00zea\x00zgh\x00zhhozhx\x00zia\x00zlm\x00zmi" +
+	"\x00zne\x00zuulzxx\x00zza\x00\xff\xff\xff\xff"
+
+const langNoIndexOffset = 1330
+
+// langNoIndex is a bit vector of all 3-letter language codes that are not used as an index
+// in lookup tables. The language ids for these language codes are derived directly
+// from the letters and are not consecutive.
+// Size: 2197 bytes, 2197 elements
+var langNoIndex = [2197]uint8{
+	// Entry 0 - 3F
+	0xff, 0xf8, 0xed, 0xfe, 0xeb, 0xd3, 0x3b, 0xd2,
+	0xfb, 0xbf, 0x7a, 0xfa, 0x37, 0x1d, 0x3c, 0x57,
+	0x6e, 0x97, 0x73, 0x38, 0xfb, 0xea, 0xbf, 0x70,
+	0xad, 0x03, 0xff, 0xff, 0xcf, 0x05, 0x84, 0x72,
+	0xe9, 0xbf, 0xfd, 0xbf, 0xbf, 0xf7, 0xfd, 0x77,
+	0x0f, 0xff, 0xef, 0x6f, 0xff, 0xfb, 0xdf, 0xe2,
+	0xc9, 0xf8, 0x7f, 0x7e, 0x4d, 0xbc, 0x0a, 0x6a,
+	0x7c, 0xea, 0xe3, 0xfa, 0x7a, 0xbf, 0x67, 0xff,
+	// Entry 40 - 7F
+	0xff, 0xff, 0xff, 0xdf, 0x2a, 0x54, 0x91, 0xc0,
+	0x5d, 0xe3, 0x97, 0x14, 0x07, 0x20, 0xdd, 0xed,
+	0x9f, 0x3f, 0xc9, 0x21, 0xf8, 0x3f, 0x94, 0x35,
+	0x7c, 0x5f, 0xff, 0x5f, 0x8e, 0x6e, 0xdf, 0xff,
+	0xff, 0xff, 0x55, 0x7c, 0xd3, 0xfd, 0xbf, 0xb5,
+	0x7b, 0xdf, 0x7f, 0xf7, 0xca, 0xfe, 0xdb, 0xa3,
+	0xa8, 0xff, 0x1f, 0x67, 0x7d, 0xeb, 0xef, 0xce,
+	0xff, 0xff, 0x9f, 0xff, 0xb7, 0xef, 0xfe, 0xcf,
+	// Entry 80 - BF
+	0xdb, 0xff, 0xf3, 0xcd, 0xfb, 0x7f, 0xff, 0xff,
+	0xbb, 0xee, 0xf7, 0xbd, 0xdb, 0xff, 0x5f, 0xf7,
+	0xfd, 0xf2, 0xfd, 0xff, 0x5e, 0x2f, 0x3b, 0xba,
+	0x7e, 0xff, 0xff, 0xfe, 0xf7, 0xff, 0xdd, 0xff,
+	0xfd, 0xdf, 0xfb, 0xfe, 0x9d, 0xb4, 0xd3, 0xff,
+	0xef, 0xff, 0xdf, 0xf7, 0x7f, 0xb7, 0xfd, 0xd5,
+	0xa5, 0x77, 0x40, 0xff, 0x9c, 0xc1, 0x41, 0x2c,
+	0x08, 0x21, 0x41, 0x00, 0x50, 0x40, 0x00, 0x80,
+	// Entry C0 - FF
+	0xfb, 0x4a, 0xf2, 0x9f, 0xb4, 0x42, 0x41, 0x96,
+	0x1b, 0x14, 0x08, 0xf3, 0x2b, 0xe7, 0x17, 0x56,
+	0x05, 0x7d, 0x0e, 0x1c, 0x37, 0x7f, 0xf3, 0xef,
+	0x97, 0xff, 0x5d, 0x38, 0x64, 0x08, 0x00, 0x10,
+	0xbc, 0x85, 0xaf, 0xdf, 0xff, 0xff, 0x7b, 0x35,
+	0x3e, 0xc7, 0xc7, 0xdf, 0xff, 0x01, 0x81, 0x00,
+	0xb0, 0x05, 0x80, 0x00, 0x20, 0x00, 0x00, 0x03,
+	0x40, 0x00, 0x40, 0x92, 0x21, 0x50, 0xb1, 0x5d,
+	// Entry 100 - 13F
+	0xfd, 0xdc, 0xbe, 0x5e, 0x00, 0x00, 0x02, 0x64,
+	0x0d, 0x19, 0x41, 0xdf, 0x79, 0x22, 0x00, 0x00,
+	0x00, 0x5e, 0x64, 0xdc, 0x24, 0xe5, 0xd9, 0xe3,
+	0xfe, 0xff, 0xfd, 0xcb, 0x9f, 0x14, 0x41, 0x0c,
+	0x86, 0x00, 0xd1, 0x00, 0xf0, 0xc7, 0x67, 0x5f,
+	0x56, 0x99, 0x5e, 0xb5, 0x6c, 0xaf, 0x03, 0x00,
+	0x02, 0x00, 0x00, 0x00, 0xc0, 0x37, 0xda, 0x56,
+	0x90, 0x6d, 0x01, 0x2e, 0x96, 0x69, 0x20, 0xfb,
+	// Entry 140 - 17F
+	0xff, 0x3f, 0x00, 0x00, 0x00, 0x01, 0x0c, 0x16,
+	0x03, 0x00, 0x00, 0xb0, 0x14, 0x23, 0x50, 0x06,
+	0x0a, 0x00, 0x01, 0x00, 0x00, 0x10, 0x11, 0x09,
+	0x00, 0x00, 0x60, 0x10, 0x00, 0x00, 0x00, 0x10,
+	0x00, 0x00, 0x44, 0x00, 0x00, 0x10, 0x00, 0x05,
+	0x08, 0x00, 0x00, 0x05, 0x00, 0x80, 0x28, 0x04,
+	0x00, 0x00, 0x40, 0xd5, 0x2d, 0x00, 0x64, 0x35,
+	0x24, 0x52, 0xf4, 0xd5, 0xbf, 0x62, 0xc9, 0x03,
+	// Entry 180 - 1BF
+	0x00, 0x80, 0x00, 0x40, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x04, 0x13, 0x39, 0x01, 0xdd, 0x57, 0x98,
+	0x21, 0x18, 0x81, 0x08, 0x00, 0x01, 0x40, 0x82,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x01, 0x40, 0x00, 0x44, 0x00, 0x00, 0x80, 0xea,
+	0xa9, 0x39, 0x00, 0x02, 0x00, 0x00, 0x00, 0x04,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x02, 0x00, 0x00, 0x00,
+	// Entry 1C0 - 1FF
+	0x00, 0x03, 0x28, 0x05, 0x00, 0x00, 0x00, 0x00,
+	0x04, 0x20, 0x04, 0xa6, 0x00, 0x04, 0x00, 0x00,
+	0x81, 0x50, 0x00, 0x00, 0x00, 0x11, 0x84, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x06, 0x55,
+	0x02, 0x10, 0x08, 0x04, 0x00, 0x00, 0x00, 0x40,
+	0x30, 0x83, 0x01, 0x00, 0x00, 0x00, 0x11, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x1e, 0xcd, 0xbf, 0x7a, 0xbf,
+	// Entry 200 - 23F
+	0xdf, 0xc3, 0x83, 0x82, 0xc0, 0xfb, 0x57, 0x27,
+	0xed, 0x55, 0xe7, 0x01, 0x00, 0x20, 0xb2, 0xc5,
+	0xa4, 0x45, 0x25, 0x9b, 0x02, 0xdf, 0xe1, 0xdf,
+	0x03, 0x44, 0x08, 0x90, 0x01, 0x04, 0x81, 0xe3,
+	0x92, 0x54, 0xdb, 0x28, 0xd3, 0x5f, 0xfe, 0x6d,
+	0x79, 0xed, 0x1c, 0x7f, 0x04, 0x08, 0x00, 0x01,
+	0x21, 0x12, 0x64, 0x5f, 0xdd, 0x0e, 0x85, 0x4f,
+	0x40, 0x40, 0x00, 0x04, 0xf1, 0xfd, 0x3d, 0x54,
+	// Entry 240 - 27F
+	0xe8, 0x03, 0xb4, 0x27, 0x23, 0x0d, 0x00, 0x00,
+	0x20, 0x7b, 0x78, 0x02, 0x07, 0x84, 0x00, 0xf0,
+	0xbb, 0x7e, 0x5a, 0x00, 0x18, 0x04, 0x81, 0x00,
+	0x00, 0x00, 0x80, 0x10, 0x90, 0x1c, 0x01, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x10, 0x40, 0x00, 0x04,
+	0x08, 0xa0, 0x70, 0xa5, 0x0c, 0x40, 0x00, 0x00,
+	0x91, 0x24, 0x04, 0x68, 0x00, 0x20, 0x70, 0xff,
+	0x7b, 0x7f, 0x70, 0x00, 0x05, 0x9b, 0xdd, 0x66,
+	// Entry 280 - 2BF
+	0x03, 0x00, 0x11, 0x00, 0x00, 0x00, 0x40, 0x05,
+	0xb5, 0xb6, 0x80, 0x08, 0x04, 0x00, 0x04, 0x51,
+	0xe2, 0xef, 0xfd, 0x3f, 0x05, 0x09, 0x08, 0x05,
+	0x40, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+	0x0c, 0x00, 0x00, 0x00, 0x00, 0x81, 0x00, 0x60,
+	0xe7, 0x48, 0x00, 0x81, 0x20, 0xc0, 0x05, 0x80,
+	0x03, 0x00, 0x00, 0x00, 0x8c, 0x50, 0x40, 0x04,
+	0x84, 0x47, 0x84, 0x40, 0x20, 0x10, 0x00, 0x20,
+	// Entry 2C0 - 2FF
+	0x02, 0x50, 0x80, 0x11, 0x00, 0x99, 0x6c, 0xe2,
+	0x50, 0x27, 0x1d, 0x11, 0x29, 0x0e, 0x59, 0xe9,
+	0x33, 0x08, 0x00, 0x20, 0x04, 0x40, 0x10, 0x00,
+	0x00, 0x00, 0x50, 0x44, 0x92, 0x49, 0xd6, 0x5d,
+	0xa7, 0x81, 0x47, 0x97, 0xfb, 0x00, 0x10, 0x00,
+	0x08, 0x00, 0x80, 0x00, 0x40, 0x04, 0x00, 0x01,
+	0x02, 0x00, 0x01, 0x40, 0x80, 0x00, 0x40, 0x08,
+	0xd8, 0xeb, 0xf6, 0x39, 0xc4, 0x8d, 0x12, 0x00,
+	// Entry 300 - 33F
+	0x00, 0x0c, 0x04, 0x01, 0x20, 0x20, 0xdd, 0xa0,
+	0x01, 0x00, 0x00, 0x00, 0x12, 0x00, 0x00, 0x00,
+	0x04, 0x10, 0xd0, 0x9d, 0x95, 0x13, 0x04, 0x80,
+	0x00, 0x01, 0xd0, 0x16, 0x40, 0x00, 0x10, 0xb0,
+	0x10, 0x62, 0x4c, 0xd2, 0x02, 0x01, 0x4a, 0x00,
+	0x46, 0x04, 0x00, 0x08, 0x02, 0x00, 0x20, 0x80,
+	0x00, 0x80, 0x06, 0x00, 0x08, 0x00, 0x00, 0x00,
+	0x00, 0xf0, 0xd8, 0x6f, 0x15, 0x02, 0x08, 0x00,
+	// Entry 340 - 37F
+	0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x10, 0x01,
+	0x00, 0x10, 0x00, 0x00, 0x00, 0xf0, 0x84, 0xe3,
+	0xdd, 0xbf, 0xf9, 0xf9, 0x3b, 0x7f, 0x7f, 0xdb,
+	0xfd, 0xfc, 0xfe, 0xdf, 0xff, 0xfd, 0xff, 0xf6,
+	0xfb, 0xfc, 0xf7, 0x1f, 0xff, 0xb3, 0x6c, 0xff,
+	0xd9, 0xad, 0xdf, 0xfe, 0xef, 0xba, 0xdf, 0xff,
+	0xff, 0xff, 0xb7, 0xdd, 0x7d, 0xbf, 0xab, 0x7f,
+	0xfd, 0xfd, 0xdf, 0x2f, 0x9c, 0xdf, 0xf3, 0x6f,
+	// Entry 380 - 3BF
+	0xdf, 0xdd, 0xff, 0xfb, 0xee, 0xd2, 0xab, 0x5f,
+	0xd5, 0xdf, 0x7f, 0xff, 0xeb, 0xff, 0xe4, 0x4d,
+	0xf9, 0xff, 0xfe, 0xf7, 0xfd, 0xdf, 0xfb, 0xbf,
+	0xee, 0xdb, 0x6f, 0xef, 0xff, 0x7f, 0xff, 0xff,
+	0xf7, 0x5f, 0xd3, 0x3b, 0xfd, 0xd9, 0xdf, 0xeb,
+	0xbc, 0x08, 0x05, 0x24, 0xff, 0x07, 0x70, 0xfe,
+	0xe6, 0x5e, 0x00, 0x08, 0x00, 0x83, 0x7d, 0x1f,
+	0x06, 0xe6, 0x72, 0x60, 0xd1, 0x3c, 0x7f, 0x44,
+	// Entry 3C0 - 3FF
+	0x02, 0x30, 0x9f, 0x7a, 0x16, 0xbd, 0x7f, 0x57,
+	0xf2, 0xff, 0x31, 0xff, 0xf2, 0x1e, 0x90, 0xf7,
+	0xf1, 0xf9, 0x45, 0x80, 0x01, 0x02, 0x00, 0x20,
+	0x40, 0x54, 0x9f, 0x8a, 0xdf, 0xf9, 0x6e, 0x11,
+	0x86, 0x51, 0xc0, 0xf3, 0xfb, 0x47, 0x40, 0x03,
+	0x05, 0xd1, 0x50, 0x5c, 0x00, 0x40, 0x00, 0x10,
+	0x04, 0x02, 0x00, 0x00, 0x0a, 0x00, 0x17, 0xd2,
+	0xb9, 0xfd, 0xfc, 0xba, 0xfe, 0xef, 0xc7, 0xbe,
+	// Entry 400 - 43F
+	0x53, 0x6f, 0xdf, 0xe7, 0xdb, 0x65, 0xbb, 0x7f,
+	0xfa, 0xff, 0x77, 0xf3, 0xef, 0xbf, 0xfd, 0xf7,
+	0xdf, 0xdf, 0x9b, 0x7f, 0xff, 0xff, 0x7f, 0x6f,
+	0xf7, 0xfb, 0xeb, 0xdf, 0xbc, 0xff, 0xbf, 0x6b,
+	0x7b, 0xfb, 0xff, 0xce, 0x76, 0xbd, 0xf7, 0xf7,
+	0xdf, 0xdc, 0xf7, 0xf7, 0xff, 0xdf, 0xf3, 0xfe,
+	0xef, 0xff, 0xff, 0xff, 0xb6, 0x7f, 0x7f, 0xde,
+	0xf7, 0xb9, 0xeb, 0x77, 0xff, 0xfb, 0xbf, 0xdf,
+	// Entry 440 - 47F
+	0xfd, 0xfe, 0xfb, 0xff, 0xfe, 0xeb, 0x1f, 0x7d,
+	0x2f, 0xfd, 0xb6, 0xb5, 0xa5, 0xfc, 0xff, 0xfd,
+	0x7f, 0x4e, 0xbf, 0x8f, 0xae, 0xff, 0xee, 0xdf,
+	0x7f, 0xf7, 0x73, 0x02, 0x02, 0x04, 0xfc, 0xf7,
+	0xff, 0xb7, 0xd7, 0xef, 0xfe, 0xcd, 0xf5, 0xce,
+	0xe2, 0x8e, 0xe7, 0xbf, 0xb7, 0xff, 0x56, 0xfd,
+	0xcd, 0xff, 0xfb, 0xff, 0xdf, 0xd7, 0xea, 0xff,
+	0xe5, 0x5f, 0x6d, 0x0f, 0xa7, 0x51, 0x06, 0xc4,
+	// Entry 480 - 4BF
+	0x93, 0x50, 0x5d, 0xaf, 0xa6, 0xff, 0x99, 0xfb,
+	0x63, 0x1d, 0x53, 0xff, 0xef, 0xb7, 0x35, 0x20,
+	0x14, 0x00, 0x55, 0x51, 0xc2, 0x65, 0xf5, 0x41,
+	0xe2, 0xff, 0xfc, 0xdf, 0x02, 0x85, 0xc5, 0x05,
+	0x00, 0x22, 0x00, 0x74, 0x69, 0x10, 0x08, 0x05,
+	0x41, 0x00, 0x01, 0x06, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x51, 0x20, 0x05, 0x04, 0x01, 0x00, 0x00,
+	0x06, 0x11, 0x20, 0x00, 0x18, 0x01, 0x92, 0xf1,
+	// Entry 4C0 - 4FF
+	0xfd, 0x47, 0x69, 0x06, 0x95, 0x06, 0x57, 0xed,
+	0xfb, 0x4d, 0x1c, 0x6b, 0x83, 0x04, 0x62, 0x40,
+	0x00, 0x11, 0x42, 0x00, 0x00, 0x00, 0x54, 0x83,
+	0xb8, 0x4f, 0x10, 0x8e, 0x89, 0x46, 0xde, 0xf7,
+	0x13, 0x31, 0x00, 0x20, 0x00, 0x00, 0x00, 0x90,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x0a, 0x10, 0x00,
+	0x01, 0x00, 0x00, 0xf0, 0x5b, 0xf4, 0xbe, 0x3d,
+	0xbe, 0xcf, 0xf7, 0xaf, 0x42, 0x04, 0x84, 0x41,
+	// Entry 500 - 53F
+	0x30, 0xff, 0x79, 0x72, 0x04, 0x00, 0x00, 0x49,
+	0x2d, 0x14, 0x27, 0x5f, 0xed, 0xf1, 0x3f, 0xe7,
+	0x3f, 0x00, 0x00, 0x02, 0xc6, 0xa0, 0x1e, 0xf8,
+	0xbb, 0xff, 0xfd, 0xfb, 0xb7, 0xfd, 0xe7, 0xf7,
+	0xfd, 0xfc, 0xd5, 0xed, 0x47, 0xf4, 0x7e, 0x10,
+	0x01, 0x01, 0x84, 0x6d, 0xff, 0xf7, 0xdd, 0xf9,
+	0x5b, 0x05, 0x86, 0xed, 0xf5, 0x77, 0xbd, 0x3c,
+	0x00, 0x00, 0x00, 0x42, 0x71, 0x42, 0x00, 0x40,
+	// Entry 540 - 57F
+	0x00, 0x00, 0x01, 0x43, 0x19, 0x24, 0x08, 0x00,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	// Entry 580 - 5BF
+	0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff, 0xff,
+	0xff, 0xab, 0xbd, 0xe7, 0x57, 0xee, 0x13, 0x5d,
+	0x09, 0xc1, 0x40, 0x21, 0xfa, 0x17, 0x01, 0x80,
+	0x00, 0x00, 0x00, 0x00, 0xf0, 0xce, 0xfb, 0xbf,
+	0x00, 0x23, 0x00, 0x00, 0x00, 0x00, 0x08, 0x00,
+	0x00, 0x30, 0x15, 0xa3, 0x10, 0x00, 0x00, 0x00,
+	0x11, 0x04, 0x16, 0x00, 0x00, 0x02, 0x20, 0x81,
+	0xa3, 0x01, 0x50, 0x00, 0x00, 0x83, 0x11, 0x40,
+	// Entry 5C0 - 5FF
+	0x00, 0x00, 0x00, 0xf0, 0xdd, 0x7b, 0xbe, 0x02,
+	0xaa, 0x10, 0x5d, 0x98, 0x52, 0x00, 0x80, 0x20,
+	0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x02, 0x02,
+	0x3d, 0x40, 0x10, 0x02, 0x10, 0x61, 0x5a, 0x9d,
+	0x31, 0x00, 0x00, 0x00, 0x01, 0x18, 0x02, 0x20,
+	0x00, 0x00, 0x01, 0x00, 0x42, 0x00, 0x20, 0x00,
+	0x00, 0x1f, 0xdf, 0xd2, 0xb9, 0xff, 0xfd, 0x3f,
+	0x1f, 0x98, 0xcf, 0x9c, 0xff, 0xaf, 0x5f, 0xfe,
+	// Entry 600 - 63F
+	0x7b, 0x4b, 0x40, 0x10, 0xe1, 0xfd, 0xaf, 0xd9,
+	0xb7, 0xf6, 0xfb, 0xb3, 0xc7, 0xff, 0x6f, 0xf1,
+	0x73, 0xb1, 0x7f, 0x9f, 0x7f, 0xbd, 0xfc, 0xb7,
+	0xee, 0x1c, 0xfa, 0xcb, 0xef, 0xdd, 0xf9, 0xbd,
+	0x6e, 0xae, 0x55, 0xfd, 0x6e, 0x81, 0x76, 0x9f,
+	0xd4, 0x77, 0xf5, 0x7d, 0xfb, 0xff, 0xeb, 0xfe,
+	0xbe, 0x5f, 0x46, 0x5b, 0xe9, 0x5f, 0x50, 0x18,
+	0x02, 0xfa, 0xf7, 0x9d, 0x15, 0x97, 0x05, 0x0f,
+	// Entry 640 - 67F
+	0x75, 0xc4, 0x7d, 0x81, 0x92, 0xf5, 0x57, 0x6c,
+	0xff, 0xe4, 0xef, 0x6f, 0xff, 0xfc, 0xdd, 0xde,
+	0xfc, 0xfd, 0x76, 0x5f, 0x7a, 0x3f, 0x00, 0x98,
+	0x02, 0xfb, 0xa3, 0xef, 0xf3, 0xd6, 0xf2, 0xff,
+	0xb9, 0xda, 0x7d, 0xd0, 0x3e, 0x15, 0x7b, 0xb4,
+	0xf5, 0x3e, 0xff, 0xff, 0xf1, 0xf7, 0xff, 0xe7,
+	0x5f, 0xff, 0xff, 0x9e, 0xdf, 0xf6, 0xd7, 0xb9,
+	0xef, 0x27, 0x80, 0xbb, 0xc5, 0xff, 0xff, 0xe3,
+	// Entry 680 - 6BF
+	0x97, 0x9d, 0xbf, 0x9f, 0xf7, 0xc7, 0xfd, 0x37,
+	0xce, 0x7f, 0x44, 0x1d, 0x73, 0x7f, 0xf8, 0xda,
+	0x5d, 0xce, 0x7d, 0x06, 0xb9, 0xea, 0x79, 0xa0,
+	0x1a, 0x20, 0x00, 0x30, 0x02, 0x04, 0x24, 0x08,
+	0x04, 0x00, 0x00, 0x40, 0xd4, 0x02, 0x04, 0x00,
+	0x00, 0x04, 0x00, 0x04, 0x00, 0x20, 0x09, 0x06,
+	0x50, 0x00, 0x08, 0x00, 0x00, 0x00, 0x24, 0x00,
+	0x04, 0x00, 0x10, 0xdc, 0x58, 0xd7, 0x0d, 0x0f,
+	// Entry 6C0 - 6FF
+	0x54, 0x4d, 0xf1, 0x16, 0x44, 0xd5, 0x42, 0x08,
+	0x40, 0x02, 0x00, 0x40, 0x00, 0x08, 0x00, 0x00,
+	0x00, 0xdc, 0xfb, 0xcb, 0x0e, 0x58, 0x48, 0x41,
+	0x24, 0x20, 0x04, 0x00, 0x30, 0x12, 0x40, 0x00,
+	0x00, 0x10, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x01, 0x00, 0x00, 0x00, 0x80, 0x10, 0x10, 0xab,
+	0x6d, 0x93, 0x00, 0x01, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x80, 0x80, 0x25, 0x00, 0x00,
+	// Entry 700 - 73F
+	0x00, 0x00, 0x00, 0x00, 0x0a, 0x00, 0x00, 0x00,
+	0x80, 0x86, 0xc2, 0x00, 0x00, 0x01, 0x00, 0x01,
+	0xff, 0x18, 0x02, 0x00, 0x02, 0xf0, 0xfd, 0x79,
+	0x3b, 0x00, 0x25, 0x00, 0x00, 0x00, 0x02, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x40, 0x00, 0x00,
+	0x03, 0x00, 0x09, 0x20, 0x00, 0x00, 0x01, 0x00,
+	0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x01, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	// Entry 740 - 77F
+	0x00, 0x00, 0x00, 0xef, 0xd5, 0xfd, 0xcf, 0x7e,
+	0xb0, 0x11, 0x00, 0x00, 0x00, 0x92, 0x01, 0x46,
+	0xcd, 0xf9, 0x5c, 0x00, 0x01, 0x00, 0x30, 0x04,
+	0x04, 0x55, 0x00, 0x01, 0x04, 0xf4, 0x3f, 0x4a,
+	0x01, 0x00, 0x00, 0xb0, 0x80, 0x20, 0x55, 0x75,
+	0x97, 0x7c, 0xdf, 0x31, 0xcc, 0x68, 0xd1, 0x03,
+	0xd5, 0x57, 0x27, 0x14, 0x01, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x2c, 0xf7, 0xcb, 0x1f, 0x14, 0x60,
+	// Entry 780 - 7BF
+	0x83, 0x68, 0x01, 0x10, 0x8b, 0x38, 0x8a, 0x01,
+	0x00, 0x00, 0x20, 0x00, 0x24, 0x44, 0x00, 0x00,
+	0x10, 0x03, 0x31, 0x02, 0x01, 0x00, 0x00, 0xf0,
+	0xf5, 0xff, 0xd5, 0x97, 0xbc, 0x70, 0xd6, 0x78,
+	0x78, 0x15, 0x50, 0x05, 0xa4, 0x84, 0xa9, 0x41,
+	0x00, 0x00, 0x00, 0x6b, 0x39, 0x52, 0x74, 0x40,
+	0xe8, 0x30, 0x90, 0x6a, 0x92, 0x00, 0x00, 0x02,
+	0xff, 0xef, 0xff, 0x4b, 0x85, 0x53, 0xf4, 0xed,
+	// Entry 7C0 - 7FF
+	0xdd, 0xbf, 0xf2, 0x5d, 0xc7, 0x0c, 0xd5, 0x42,
+	0xfc, 0xff, 0xf7, 0x1f, 0x00, 0x80, 0x40, 0x56,
+	0xcc, 0x16, 0x9e, 0xea, 0x35, 0x7d, 0xef, 0xff,
+	0xbd, 0xa4, 0xaf, 0x01, 0x44, 0x18, 0x01, 0x4d,
+	0x4e, 0x4a, 0x08, 0x50, 0x28, 0x30, 0xe0, 0x80,
+	0x10, 0x20, 0x24, 0x00, 0xff, 0x2f, 0xd3, 0x60,
+	0xfe, 0x01, 0x02, 0x88, 0x2a, 0x40, 0x16, 0x01,
+	0x01, 0x15, 0x2b, 0x3c, 0x01, 0x00, 0x00, 0x10,
+	// Entry 800 - 83F
+	0x90, 0x49, 0x41, 0x02, 0x02, 0x01, 0xe1, 0xbf,
+	0xbf, 0x03, 0x00, 0x00, 0x10, 0xdc, 0xa3, 0xd1,
+	0x40, 0x9c, 0x44, 0xdf, 0xf5, 0x8f, 0x66, 0xb3,
+	0x55, 0x20, 0xd4, 0xc1, 0xd8, 0x30, 0x3d, 0x80,
+	0x00, 0x00, 0x00, 0x04, 0xd4, 0x11, 0xc5, 0x84,
+	0x2f, 0x50, 0x00, 0x22, 0x50, 0x6e, 0xbd, 0x93,
+	0x07, 0x00, 0x20, 0x10, 0x84, 0xb2, 0x45, 0x10,
+	0x06, 0x44, 0x00, 0x00, 0x12, 0x02, 0x11, 0x00,
+	// Entry 840 - 87F
+	0xf0, 0xfb, 0xfd, 0x7f, 0x05, 0x00, 0x16, 0x89,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x0c, 0x03,
+	0x00, 0x00, 0x00, 0x00, 0x03, 0x30, 0x02, 0x28,
+	0x84, 0x00, 0x21, 0xc0, 0x23, 0x24, 0x00, 0x00,
+	0x00, 0xcb, 0xe4, 0x3a, 0x46, 0x88, 0x54, 0xf1,
+	0xef, 0xff, 0x7f, 0x12, 0x01, 0x01, 0x84, 0x50,
+	0x07, 0xfc, 0xff, 0xff, 0x0f, 0x01, 0x00, 0x40,
+	0x10, 0x38, 0x01, 0x01, 0x1c, 0x12, 0x40, 0xe1,
+	// Entry 880 - 8BF
+	0x76, 0x16, 0x08, 0x03, 0x10, 0x00, 0x00, 0x00,
+	0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x24,
+	0x0a, 0x00, 0x80, 0x00, 0x00,
+}
+
+// altLangISO3 holds an alphabetically sorted list of 3-letter language code alternatives
+// to 2-letter language codes that cannot be derived using the method described above.
+// Each 3-letter code is followed by its 1-byte langID.
+const altLangISO3 tag.Index = "---\x00cor\x00hbs\x01heb\x02kin\x03spa\x04yid\x05\xff\xff\xff\xff"
+
+// altLangIndex is used to convert indexes in altLangISO3 to langIDs.
+// Size: 12 bytes, 6 elements
+var altLangIndex = [6]uint16{
+	0x0281, 0x0407, 0x01fb, 0x03e5, 0x013e, 0x0208,
+}
+
+// AliasMap maps langIDs to their suggested replacements.
+// Size: 772 bytes, 193 elements
+var AliasMap = [193]FromTo{
+	0:   {From: 0x82, To: 0x88},
+	1:   {From: 0x187, To: 0x1ae},
+	2:   {From: 0x1f3, To: 0x1e1},
+	3:   {From: 0x1fb, To: 0x1bc},
+	4:   {From: 0x208, To: 0x512},
+	5:   {From: 0x20f, To: 0x20e},
+	6:   {From: 0x310, To: 0x3dc},
+	7:   {From: 0x347, To: 0x36f},
+	8:   {From: 0x407, To: 0x432},
+	9:   {From: 0x47a, To: 0x153},
+	10:  {From: 0x490, To: 0x451},
+	11:  {From: 0x4a2, To: 0x21},
+	12:  {From: 0x53e, To: 0x544},
+	13:  {From: 0x58f, To: 0x12d},
+	14:  {From: 0x62b, To: 0x34},
+	15:  {From: 0x62f, To: 0x14},
+	16:  {From: 0x630, To: 0x1eb1},
+	17:  {From: 0x651, To: 0x431},
+	18:  {From: 0x662, To: 0x431},
+	19:  {From: 0x6ed, To: 0x3a},
+	20:  {From: 0x6f8, To: 0x1d7},
+	21:  {From: 0x709, To: 0x3625},
+	22:  {From: 0x73e, To: 0x21a1},
+	23:  {From: 0x7b3, To: 0x56},
+	24:  {From: 0x7b9, To: 0x299b},
+	25:  {From: 0x7c5, To: 0x58},
+	26:  {From: 0x7e6, To: 0x145},
+	27:  {From: 0x80c, To: 0x5a},
+	28:  {From: 0x815, To: 0x8d},
+	29:  {From: 0x87e, To: 0x810},
+	30:  {From: 0x8a8, To: 0x8b7},
+	31:  {From: 0x8c3, To: 0xee3},
+	32:  {From: 0x8fa, To: 0x1dc},
+	33:  {From: 0x9ef, To: 0x331},
+	34:  {From: 0xa36, To: 0x2c5},
+	35:  {From: 0xa3d, To: 0xbf},
+	36:  {From: 0xabe, To: 0x3322},
+	37:  {From: 0xb38, To: 0x529},
+	38:  {From: 0xb75, To: 0x265a},
+	39:  {From: 0xb7e, To: 0xbc3},
+	40:  {From: 0xb9b, To: 0x44e},
+	41:  {From: 0xbbc, To: 0x4229},
+	42:  {From: 0xbbf, To: 0x529},
+	43:  {From: 0xbfe, To: 0x2da7},
+	44:  {From: 0xc2e, To: 0x3181},
+	45:  {From: 0xcb9, To: 0xf3},
+	46:  {From: 0xd08, To: 0xfa},
+	47:  {From: 0xdc8, To: 0x11a},
+	48:  {From: 0xdd7, To: 0x32d},
+	49:  {From: 0xdf8, To: 0xdfb},
+	50:  {From: 0xdfe, To: 0x531},
+	51:  {From: 0xe01, To: 0xdf3},
+	52:  {From: 0xedf, To: 0x205a},
+	53:  {From: 0xee9, To: 0x222e},
+	54:  {From: 0xeee, To: 0x2e9a},
+	55:  {From: 0xf39, To: 0x367},
+	56:  {From: 0x10d0, To: 0x140},
+	57:  {From: 0x1104, To: 0x2d0},
+	58:  {From: 0x11a0, To: 0x1ec},
+	59:  {From: 0x1279, To: 0x21},
+	60:  {From: 0x1424, To: 0x15e},
+	61:  {From: 0x1470, To: 0x14e},
+	62:  {From: 0x151f, To: 0xd9b},
+	63:  {From: 0x1523, To: 0x390},
+	64:  {From: 0x1532, To: 0x19f},
+	65:  {From: 0x1580, To: 0x210},
+	66:  {From: 0x1583, To: 0x10d},
+	67:  {From: 0x15a3, To: 0x3caf},
+	68:  {From: 0x1630, To: 0x222e},
+	69:  {From: 0x166a, To: 0x19b},
+	70:  {From: 0x16c8, To: 0x136},
+	71:  {From: 0x1700, To: 0x29f8},
+	72:  {From: 0x1718, To: 0x194},
+	73:  {From: 0x1727, To: 0xf3f},
+	74:  {From: 0x177a, To: 0x178},
+	75:  {From: 0x1809, To: 0x17b6},
+	76:  {From: 0x1816, To: 0x18f3},
+	77:  {From: 0x188a, To: 0x436},
+	78:  {From: 0x1979, To: 0x1d01},
+	79:  {From: 0x1a74, To: 0x2bb0},
+	80:  {From: 0x1a8a, To: 0x1f8},
+	81:  {From: 0x1b5a, To: 0x1fa},
+	82:  {From: 0x1b86, To: 0x1515},
+	83:  {From: 0x1d64, To: 0x2c9b},
+	84:  {From: 0x2038, To: 0x37b1},
+	85:  {From: 0x203d, To: 0x20dd},
+	86:  {From: 0x2042, To: 0x2e00},
+	87:  {From: 0x205a, To: 0x30b},
+	88:  {From: 0x20e3, To: 0x274},
+	89:  {From: 0x20ee, To: 0x263},
+	90:  {From: 0x20f2, To: 0x22d},
+	91:  {From: 0x20f9, To: 0x256},
+	92:  {From: 0x210f, To: 0x21eb},
+	93:  {From: 0x2135, To: 0x27d},
+	94:  {From: 0x2160, To: 0x913},
+	95:  {From: 0x2199, To: 0x121},
+	96:  {From: 0x21ce, To: 0x1561},
+	97:  {From: 0x21e6, To: 0x504},
+	98:  {From: 0x21f4, To: 0x49f},
+	99:  {From: 0x21fb, To: 0x269},
+	100: {From: 0x222d, To: 0x121},
+	101: {From: 0x2237, To: 0x121},
+	102: {From: 0x2248, To: 0x217d},
+	103: {From: 0x2262, To: 0x92a},
+	104: {From: 0x2316, To: 0x3226},
+	105: {From: 0x236a, To: 0x2835},
+	106: {From: 0x2382, To: 0x3365},
+	107: {From: 0x2472, To: 0x2c7},
+	108: {From: 0x24e4, To: 0x2ff},
+	109: {From: 0x24f0, To: 0x2fa},
+	110: {From: 0x24fa, To: 0x31f},
+	111: {From: 0x2550, To: 0xb5b},
+	112: {From: 0x25a9, To: 0xe2},
+	113: {From: 0x263e, To: 0x2d0},
+	114: {From: 0x26c9, To: 0x26b4},
+	115: {From: 0x26f9, To: 0x3c8},
+	116: {From: 0x2727, To: 0x3caf},
+	117: {From: 0x2755, To: 0x6a4},
+	118: {From: 0x2765, To: 0x26b4},
+	119: {From: 0x2789, To: 0x4358},
+	120: {From: 0x27c9, To: 0x2001},
+	121: {From: 0x28ea, To: 0x27b1},
+	122: {From: 0x28ef, To: 0x2837},
+	123: {From: 0x28fe, To: 0xaa5},
+	124: {From: 0x2914, To: 0x351},
+	125: {From: 0x2986, To: 0x2da7},
+	126: {From: 0x29f0, To: 0x96b},
+	127: {From: 0x2b1a, To: 0x38d},
+	128: {From: 0x2bfc, To: 0x395},
+	129: {From: 0x2c3f, To: 0x3caf},
+	130: {From: 0x2ce1, To: 0x2201},
+	131: {From: 0x2cfc, To: 0x3be},
+	132: {From: 0x2d13, To: 0x597},
+	133: {From: 0x2d47, To: 0x148},
+	134: {From: 0x2d48, To: 0x148},
+	135: {From: 0x2dff, To: 0x2f1},
+	136: {From: 0x2e08, To: 0x19cc},
+	137: {From: 0x2e10, To: 0xc45},
+	138: {From: 0x2e1a, To: 0x2d95},
+	139: {From: 0x2e21, To: 0x292},
+	140: {From: 0x2e54, To: 0x7d},
+	141: {From: 0x2e65, To: 0x2282},
+	142: {From: 0x2e97, To: 0x1a4},
+	143: {From: 0x2ea0, To: 0x2e9b},
+	144: {From: 0x2eef, To: 0x2ed7},
+	145: {From: 0x3193, To: 0x3c4},
+	146: {From: 0x3366, To: 0x338e},
+	147: {From: 0x342a, To: 0x3dc},
+	148: {From: 0x34ee, To: 0x18d0},
+	149: {From: 0x35c8, To: 0x2c9b},
+	150: {From: 0x35e6, To: 0x412},
+	151: {From: 0x35f5, To: 0x24b},
+	152: {From: 0x360d, To: 0x1dc},
+	153: {From: 0x3658, To: 0x246},
+	154: {From: 0x3676, To: 0x3f4},
+	155: {From: 0x36fd, To: 0x445},
+	156: {From: 0x3747, To: 0x3b42},
+	157: {From: 0x37c0, To: 0x121},
+	158: {From: 0x3816, To: 0x38f2},
+	159: {From: 0x382a, To: 0x2b48},
+	160: {From: 0x382b, To: 0x2c9b},
+	161: {From: 0x382f, To: 0xa9},
+	162: {From: 0x3832, To: 0x3228},
+	163: {From: 0x386c, To: 0x39a6},
+	164: {From: 0x3892, To: 0x3fc0},
+	165: {From: 0x38a0, To: 0x45f},
+	166: {From: 0x38a5, To: 0x39d7},
+	167: {From: 0x38b4, To: 0x1fa4},
+	168: {From: 0x38b5, To: 0x2e9a},
+	169: {From: 0x38fa, To: 0x38f1},
+	170: {From: 0x395c, To: 0x47e},
+	171: {From: 0x3b4e, To: 0xd91},
+	172: {From: 0x3b78, To: 0x137},
+	173: {From: 0x3c99, To: 0x4bc},
+	174: {From: 0x3fbd, To: 0x100},
+	175: {From: 0x4208, To: 0xa91},
+	176: {From: 0x42be, To: 0x573},
+	177: {From: 0x42f9, To: 0x3f60},
+	178: {From: 0x4378, To: 0x25a},
+	179: {From: 0x43b8, To: 0xe6c},
+	180: {From: 0x43cd, To: 0x10f},
+	181: {From: 0x43d4, To: 0x4848},
+	182: {From: 0x44af, To: 0x3322},
+	183: {From: 0x44e3, To: 0x512},
+	184: {From: 0x45ca, To: 0x2409},
+	185: {From: 0x45dd, To: 0x26dc},
+	186: {From: 0x4610, To: 0x48ae},
+	187: {From: 0x46ae, To: 0x46a0},
+	188: {From: 0x473e, To: 0x4745},
+	189: {From: 0x4817, To: 0x3503},
+	190: {From: 0x483b, To: 0x208b},
+	191: {From: 0x4916, To: 0x31f},
+	192: {From: 0x49a7, To: 0x523},
+}
+
+// Size: 193 bytes, 193 elements
+var AliasTypes = [193]AliasType{
+	// Entry 0 - 3F
+	1, 0, 0, 0, 0, 0, 0, 1, 2, 2, 0, 1, 0, 0, 0, 0,
+	1, 2, 1, 1, 2, 0, 0, 1, 0, 1, 2, 1, 1, 0, 0, 0,
+	0, 2, 1, 1, 0, 2, 0, 0, 1, 0, 1, 0, 0, 1, 2, 1,
+	1, 1, 1, 0, 0, 0, 0, 2, 1, 1, 1, 1, 2, 1, 0, 1,
+	// Entry 40 - 7F
+	1, 2, 2, 0, 0, 1, 2, 0, 1, 0, 1, 1, 1, 1, 0, 0,
+	2, 1, 0, 0, 0, 0, 0, 1, 1, 1, 1, 1, 0, 1, 0, 0,
+	0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 2, 2, 2, 0,
+	1, 1, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1,
+	// Entry 80 - BF
+	1, 0, 0, 1, 0, 2, 1, 1, 0, 0, 0, 1, 0, 0, 0, 0,
+	0, 1, 1, 2, 0, 0, 2, 0, 0, 1, 1, 1, 0, 0, 0, 0,
+	0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 1, 1, 0, 1, 2, 0,
+	0, 0, 1, 0, 1, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 1,
+	// Entry C0 - FF
+	1,
+}
+
+const (
+	_Latn = 91
+	_Hani = 57
+	_Hans = 59
+	_Hant = 60
+	_Qaaa = 149
+	_Qaai = 157
+	_Qabx = 198
+	_Zinh = 255
+	_Zyyy = 260
+	_Zzzz = 261
+)
+
+// script is an alphabetically sorted list of ISO 15924 codes. The index
+// of the script in the string, divided by 4, is the internal scriptID.
+const script tag.Index = "" + // Size: 1052 bytes
+	"----AdlmAfakAghbAhomArabAranArmiArmnAvstBaliBamuBassBatkBengBhksBlisBopo" +
+	"BrahBraiBugiBuhdCakmCansCariChamCherChrsCirtCoptCpmnCprtCyrlCyrsDevaDiak" +
+	"DogrDsrtDuplEgydEgyhEgypElbaElymEthiGeokGeorGlagGongGonmGothGranGrekGujr" +
+	"GuruHanbHangHaniHanoHansHantHatrHebrHiraHluwHmngHmnpHrktHungIndsItalJamo" +
+	"JavaJpanJurcKaliKanaKawiKharKhmrKhojKitlKitsKndaKoreKpelKthiLanaLaooLatf" +
+	"LatgLatnLekeLepcLimbLinaLinbLisuLomaLyciLydiMahjMakaMandManiMarcMayaMedf" +
+	"MendMercMeroMlymModiMongMoonMrooMteiMultMymrNagmNandNarbNbatNewaNkdbNkgb" +
+	"NkooNshuOgamOlckOrkhOryaOsgeOsmaOugrPalmPaucPcunPelmPermPhagPhliPhlpPhlv" +
+	"PhnxPiqdPlrdPrtiPsinQaaaQaabQaacQaadQaaeQaafQaagQaahQaaiQaajQaakQaalQaam" +
+	"QaanQaaoQaapQaaqQaarQaasQaatQaauQaavQaawQaaxQaayQaazQabaQabbQabcQabdQabe" +
+	"QabfQabgQabhQabiQabjQabkQablQabmQabnQaboQabpQabqQabrQabsQabtQabuQabvQabw" +
+	"QabxRanjRjngRohgRoroRunrSamrSaraSarbSaurSgnwShawShrdShuiSiddSindSinhSogd" +
+	"SogoSoraSoyoSundSunuSyloSyrcSyreSyrjSyrnTagbTakrTaleTaluTamlTangTavtTelu" +
+	"TengTfngTglgThaaThaiTibtTirhTnsaTotoUgarVaiiVispVithWaraWchoWoleXpeoXsux" +
+	"YeziYiiiZanbZinhZmthZsyeZsymZxxxZyyyZzzz\xff\xff\xff\xff"
+
+// suppressScript is an index from langID to the dominant script for that language,
+// if it exists.  If a script is given, it should be suppressed from the language tag.
+// Size: 1330 bytes, 1330 elements
+var suppressScript = [1330]uint8{
+	// Entry 0 - 3F
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x2c,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x05, 0x00, 0x00, 0x00, 0x00, 0x00,
+	// Entry 40 - 7F
+	0x00, 0x00, 0x00, 0x0e, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x20, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,
+	// Entry 80 - BF
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x0e, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	// Entry C0 - FF
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x00,
+	// Entry 100 - 13F
+	0x5b, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0xed, 0x00, 0x00, 0x00, 0x00, 0xef, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x34, 0x00,
+	0x00, 0x5b, 0x00, 0x00, 0x5b, 0x00, 0x5b, 0x00,
+	// Entry 140 - 17F
+	0x5b, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00,
+	0x05, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x5b, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00,
+	0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x00,
+	0x00, 0x5b, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x5b, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	// Entry 180 - 1BF
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x5b, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x5b, 0x35, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x3e, 0x00, 0x22, 0x00,
+	// Entry 1C0 - 1FF
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x5b, 0x5b, 0x00, 0x5b, 0x5b, 0x00, 0x08,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x00,
+	0x5b, 0x5b, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00,
+	// Entry 200 - 23F
+	0x49, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x2e, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	// Entry 240 - 27F
+	0x00, 0x00, 0x20, 0x00, 0x00, 0x5b, 0x00, 0x00,
+	0x00, 0x00, 0x4f, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x53, 0x00, 0x00, 0x54, 0x00, 0x22, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	// Entry 280 - 2BF
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00,
+	0x58, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	// Entry 2C0 - 2FF
+	0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x22, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20,
+	// Entry 300 - 33F
+	0x00, 0x00, 0x00, 0x00, 0x6f, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x22, 0x00, 0x00, 0x00, 0x5b,
+	0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x76, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x00,
+	// Entry 340 - 37F
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b, 0x00,
+	0x5b, 0x22, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b,
+	0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x5b,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x7e, 0x5b, 0x00,
+	0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x00,
+	// Entry 380 - 3BF
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x5b, 0x00, 0x00, 0x00, 0x00, 0x83, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x36, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x05, 0x00,
+	// Entry 3C0 - 3FF
+	0x5b, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00,
+	0x00, 0x5b, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x20, 0x00, 0x00, 0x5b, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	// Entry 400 - 43F
+	0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0xd6, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x5b, 0x00,
+	0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b,
+	0x00, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x00,
+	// Entry 440 - 47F
+	0x00, 0x00, 0x00, 0x00, 0x5b, 0x5b, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0xe6, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0xe9, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0xee, 0x00, 0x00, 0x00, 0x2c,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b,
+	0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x5b, 0x00,
+	// Entry 480 - 4BF
+	0x5b, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x5b, 0x00,
+	0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x5b, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x5b, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x20, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x05, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	// Entry 4C0 - 4FF
+	0x5b, 0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x5b, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	// Entry 500 - 53F
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x3e, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x10, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x5b,
+	0x00, 0x00,
+}
+
+const (
+	_001 = 1
+	_419 = 31
+	_BR  = 65
+	_CA  = 73
+	_ES  = 111
+	_GB  = 124
+	_MD  = 189
+	_PT  = 239
+	_UK  = 307
+	_US  = 310
+	_ZZ  = 358
+	_XA  = 324
+	_XC  = 326
+	_XK  = 334
+)
+
+// isoRegionOffset needs to be added to the index of regionISO to obtain the regionID
+// for 2-letter ISO codes. (The first isoRegionOffset regionIDs are reserved for
+// the UN.M49 codes used for groups.)
+const isoRegionOffset = 32
+
+// regionTypes defines the status of a region for various standards.
+// Size: 359 bytes, 359 elements
+var regionTypes = [359]uint8{
+	// Entry 0 - 3F
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x05, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	// Entry 40 - 7F
+	0x06, 0x06, 0x06, 0x06, 0x04, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x04, 0x04, 0x06,
+	0x04, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x04, 0x06, 0x04, 0x06, 0x06, 0x06, 0x06, 0x00,
+	0x06, 0x04, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x04, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x00, 0x06, 0x04, 0x06, 0x06, 0x06, 0x06, 0x06,
+	// Entry 80 - BF
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x00, 0x04, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x00, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	// Entry C0 - FF
+	0x06, 0x06, 0x00, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x00, 0x06, 0x06, 0x06, 0x06, 0x00, 0x06, 0x04,
+	0x06, 0x06, 0x06, 0x06, 0x00, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x00, 0x06, 0x06, 0x00, 0x06, 0x05, 0x05, 0x05,
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+	// Entry 100 - 13F
+	0x05, 0x05, 0x05, 0x06, 0x00, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x04,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x02, 0x06, 0x04, 0x06, 0x06,
+	0x06, 0x06, 0x06, 0x00, 0x06, 0x06, 0x06, 0x06,
+	// Entry 140 - 17F
+	0x06, 0x06, 0x00, 0x06, 0x05, 0x05, 0x05, 0x05,
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x05,
+	0x05, 0x05, 0x05, 0x05, 0x05, 0x05, 0x04, 0x06,
+	0x06, 0x04, 0x06, 0x06, 0x04, 0x06, 0x05,
+}
+
+// regionISO holds a list of alphabetically sorted 2-letter ISO region codes.
+// Each 2-letter codes is followed by two bytes with the following meaning:
+//   - [A-Z}{2}: the first letter of the 2-letter code plus these two
+//     letters form the 3-letter ISO code.
+//   - 0, n:     index into altRegionISO3.
+const regionISO tag.Index = "" + // Size: 1312 bytes
+	"AAAAACSCADNDAEREAFFGAGTGAIIAALLBAMRMANNTAOGOAQTAARRGASSMATUTAUUSAWBWAXLA" +
+	"AZZEBAIHBBRBBDGDBEELBFFABGGRBHHRBIDIBJENBLLMBMMUBNRNBOOLBQESBRRABSHSBTTN" +
+	"BUURBVVTBWWABYLRBZLZCAANCCCKCDODCFAFCGOGCHHECIIVCKOKCLHLCMMRCNHNCOOLCPPT" +
+	"CQ  CRRICS\x00\x00CTTECUUBCVPVCWUWCXXRCYYPCZZEDDDRDEEUDGGADJJIDKNKDMMADO" +
+	"OMDYHYDZZAEA  ECCUEESTEGGYEHSHERRIESSPETTHEU\x00\x03EZ  FIINFJJIFKLKFMSM" +
+	"FOROFQ\x00\x18FRRAFXXXGAABGBBRGDRDGEEOGFUFGGGYGHHAGIIBGLRLGMMBGNINGPLPGQ" +
+	"NQGRRCGS\x00\x06GTTMGUUMGWNBGYUYHKKGHMMDHNNDHRRVHTTIHUUNHVVOIC  IDDNIERL" +
+	"ILSRIMMNINNDIOOTIQRQIRRNISSLITTAJEEYJMAMJOORJPPNJTTNKEENKGGZKHHMKIIRKM" +
+	"\x00\x09KNNAKP\x00\x0cKRORKWWTKY\x00\x0fKZAZLAAOLBBNLCCALIIELKKALRBRLSSO" +
+	"LTTULUUXLVVALYBYMAARMCCOMDDAMENEMFAFMGDGMHHLMIIDMKKDMLLIMMMRMNNGMOACMPNP" +
+	"MQTQMRRTMSSRMTLTMUUSMVDVMWWIMXEXMYYSMZOZNAAMNCCLNEERNFFKNGGANHHBNIICNLLD" +
+	"NOORNPPLNQ\x00\x1eNRRUNTTZNUIUNZZLOMMNPAANPCCIPEERPFYFPGNGPHHLPKAKPLOLPM" +
+	"\x00\x12PNCNPRRIPSSEPTRTPUUSPWLWPYRYPZCZQAATQMMMQNNNQOOOQPPPQQQQQRRRQSSS" +
+	"QTTTQU\x00\x03QVVVQWWWQXXXQYYYQZZZREEURHHOROOURS\x00\x15RUUSRWWASAAUSBLB" +
+	"SCYCSDDNSEWESGGPSHHNSIVNSJJMSKVKSLLESMMRSNENSOOMSRURSSSDSTTPSUUNSVLVSXXM" +
+	"SYYRSZWZTAAATCCATDCDTF\x00\x18TGGOTHHATJJKTKKLTLLSTMKMTNUNTOONTPMPTRURTT" +
+	"TOTVUVTWWNTZZAUAKRUGGAUK  UMMIUN  USSAUYRYUZZBVAATVCCTVDDRVEENVGGBVIIRVN" +
+	"NMVUUTWFLFWKAKWSSMXAAAXBBBXCCCXDDDXEEEXFFFXGGGXHHHXIIIXJJJXKKKXLLLXMMMXN" +
+	"NNXOOOXPPPXQQQXRRRXSSSXTTTXUUUXVVVXWWWXXXXXYYYXZZZYDMDYEEMYT\x00\x1bYUUG" +
+	"ZAAFZMMBZRARZWWEZZZZ\xff\xff\xff\xff"
+
+// altRegionISO3 holds a list of 3-letter region codes that cannot be
+// mapped to 2-letter codes using the default algorithm. This is a short list.
+const altRegionISO3 string = "SCGQUUSGSCOMPRKCYMSPMSRBATFMYTATN"
+
+// altRegionIDs holds a list of regionIDs the positions of which match those
+// of the 3-letter ISO codes in altRegionISO3.
+// Size: 22 bytes, 11 elements
+var altRegionIDs = [11]uint16{
+	0x0058, 0x0071, 0x0089, 0x00a9, 0x00ab, 0x00ae, 0x00eb, 0x0106,
+	0x0122, 0x0160, 0x00dd,
+}
+
+// Size: 80 bytes, 20 elements
+var regionOldMap = [20]FromTo{
+	0:  {From: 0x44, To: 0xc5},
+	1:  {From: 0x59, To: 0xa8},
+	2:  {From: 0x60, To: 0x61},
+	3:  {From: 0x67, To: 0x3b},
+	4:  {From: 0x7a, To: 0x79},
+	5:  {From: 0x94, To: 0x37},
+	6:  {From: 0xa4, To: 0x134},
+	7:  {From: 0xc2, To: 0x134},
+	8:  {From: 0xd8, To: 0x140},
+	9:  {From: 0xdd, To: 0x2b},
+	10: {From: 0xf0, To: 0x134},
+	11: {From: 0xf3, To: 0xe3},
+	12: {From: 0xfd, To: 0x71},
+	13: {From: 0x104, To: 0x165},
+	14: {From: 0x12b, To: 0x127},
+	15: {From: 0x133, To: 0x7c},
+	16: {From: 0x13b, To: 0x13f},
+	17: {From: 0x142, To: 0x134},
+	18: {From: 0x15e, To: 0x15f},
+	19: {From: 0x164, To: 0x4b},
+}
+
+// m49 maps regionIDs to UN.M49 codes. The first isoRegionOffset entries are
+// codes indicating collections of regions.
+// Size: 718 bytes, 359 elements
+var m49 = [359]int16{
+	// Entry 0 - 3F
+	0, 1, 2, 3, 5, 9, 11, 13,
+	14, 15, 17, 18, 19, 21, 29, 30,
+	34, 35, 39, 53, 54, 57, 61, 142,
+	143, 145, 150, 151, 154, 155, 202, 419,
+	958, 0, 20, 784, 4, 28, 660, 8,
+	51, 530, 24, 10, 32, 16, 40, 36,
+	533, 248, 31, 70, 52, 50, 56, 854,
+	100, 48, 108, 204, 652, 60, 96, 68,
+	// Entry 40 - 7F
+	535, 76, 44, 64, 104, 74, 72, 112,
+	84, 124, 166, 180, 140, 178, 756, 384,
+	184, 152, 120, 156, 170, 0, 0, 188,
+	891, 296, 192, 132, 531, 162, 196, 203,
+	278, 276, 0, 262, 208, 212, 214, 204,
+	12, 0, 218, 233, 818, 732, 232, 724,
+	231, 967, 0, 246, 242, 238, 583, 234,
+	0, 250, 249, 266, 826, 308, 268, 254,
+	// Entry 80 - BF
+	831, 288, 292, 304, 270, 324, 312, 226,
+	300, 239, 320, 316, 624, 328, 344, 334,
+	340, 191, 332, 348, 854, 0, 360, 372,
+	376, 833, 356, 86, 368, 364, 352, 380,
+	832, 388, 400, 392, 581, 404, 417, 116,
+	296, 174, 659, 408, 410, 414, 136, 398,
+	418, 422, 662, 438, 144, 430, 426, 440,
+	442, 428, 434, 504, 492, 498, 499, 663,
+	// Entry C0 - FF
+	450, 584, 581, 807, 466, 104, 496, 446,
+	580, 474, 478, 500, 470, 480, 462, 454,
+	484, 458, 508, 516, 540, 562, 574, 566,
+	548, 558, 528, 578, 524, 10, 520, 536,
+	570, 554, 512, 591, 0, 604, 258, 598,
+	608, 586, 616, 666, 612, 630, 275, 620,
+	581, 585, 600, 591, 634, 959, 960, 961,
+	962, 963, 964, 965, 966, 967, 968, 969,
+	// Entry 100 - 13F
+	970, 971, 972, 638, 716, 642, 688, 643,
+	646, 682, 90, 690, 729, 752, 702, 654,
+	705, 744, 703, 694, 674, 686, 706, 740,
+	728, 678, 810, 222, 534, 760, 748, 0,
+	796, 148, 260, 768, 764, 762, 772, 626,
+	795, 788, 776, 626, 792, 780, 798, 158,
+	834, 804, 800, 826, 581, 0, 840, 858,
+	860, 336, 670, 704, 862, 92, 850, 704,
+	// Entry 140 - 17F
+	548, 876, 581, 882, 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, 720, 887,
+	175, 891, 710, 894, 180, 716, 999,
+}
+
+// m49Index gives indexes into fromM49 based on the three most significant bits
+// of a 10-bit UN.M49 code. To search an UN.M49 code in fromM49, search in
+//
+//	fromM49[m49Index[msb39(code)]:m49Index[msb3(code)+1]]
+//
+// for an entry where the first 7 bits match the 7 lsb of the UN.M49 code.
+// The region code is stored in the 9 lsb of the indexed value.
+// Size: 18 bytes, 9 elements
+var m49Index = [9]int16{
+	0, 59, 108, 143, 181, 220, 259, 291,
+	333,
+}
+
+// fromM49 contains entries to map UN.M49 codes to regions. See m49Index for details.
+// Size: 666 bytes, 333 elements
+var fromM49 = [333]uint16{
+	// Entry 0 - 3F
+	0x0201, 0x0402, 0x0603, 0x0824, 0x0a04, 0x1027, 0x1205, 0x142b,
+	0x1606, 0x1868, 0x1a07, 0x1c08, 0x1e09, 0x202d, 0x220a, 0x240b,
+	0x260c, 0x2822, 0x2a0d, 0x302a, 0x3825, 0x3a0e, 0x3c0f, 0x3e32,
+	0x402c, 0x4410, 0x4611, 0x482f, 0x4e12, 0x502e, 0x5842, 0x6039,
+	0x6435, 0x6628, 0x6834, 0x6a13, 0x6c14, 0x7036, 0x7215, 0x783d,
+	0x7a16, 0x8043, 0x883f, 0x8c33, 0x9046, 0x9445, 0x9841, 0xa848,
+	0xac9b, 0xb50a, 0xb93d, 0xc03e, 0xc838, 0xd0c5, 0xd83a, 0xe047,
+	0xe8a7, 0xf052, 0xf849, 0x085b, 0x10ae, 0x184c, 0x1c17, 0x1e18,
+	// Entry 40 - 7F
+	0x20b4, 0x2219, 0x2921, 0x2c1a, 0x2e1b, 0x3051, 0x341c, 0x361d,
+	0x3853, 0x3d2f, 0x445d, 0x4c4a, 0x5454, 0x5ca9, 0x5f60, 0x644d,
+	0x684b, 0x7050, 0x7857, 0x7e91, 0x805a, 0x885e, 0x941e, 0x965f,
+	0x983b, 0xa064, 0xa865, 0xac66, 0xb46a, 0xbd1b, 0xc487, 0xcc70,
+	0xce70, 0xd06e, 0xd26b, 0xd477, 0xdc75, 0xde89, 0xe474, 0xec73,
+	0xf031, 0xf27a, 0xf479, 0xfc7f, 0x04e6, 0x0922, 0x0c63, 0x147b,
+	0x187e, 0x1c84, 0x26ee, 0x2861, 0x2c60, 0x3061, 0x4081, 0x4882,
+	0x50a8, 0x5888, 0x6083, 0x687d, 0x7086, 0x788b, 0x808a, 0x8885,
+	// Entry 80 - BF
+	0x908d, 0x9892, 0x9c8f, 0xa139, 0xa890, 0xb08e, 0xb893, 0xc09e,
+	0xc89a, 0xd096, 0xd89d, 0xe09c, 0xe897, 0xf098, 0xf89f, 0x004f,
+	0x08a1, 0x10a3, 0x1caf, 0x20a2, 0x28a5, 0x30ab, 0x34ac, 0x3cad,
+	0x42a6, 0x44b0, 0x461f, 0x4cb1, 0x54b6, 0x58b9, 0x5cb5, 0x64ba,
+	0x6cb3, 0x70b7, 0x74b8, 0x7cc7, 0x84c0, 0x8ccf, 0x94d1, 0x9cce,
+	0xa4c4, 0xaccc, 0xb4c9, 0xbcca, 0xc0cd, 0xc8d0, 0xd8bc, 0xe0c6,
+	0xe4bd, 0xe6be, 0xe8cb, 0xf0bb, 0xf8d2, 0x00e2, 0x08d3, 0x10de,
+	0x18dc, 0x20da, 0x2429, 0x265c, 0x2a30, 0x2d1c, 0x2e40, 0x30df,
+	// Entry C0 - FF
+	0x38d4, 0x4940, 0x54e1, 0x5cd9, 0x64d5, 0x6cd7, 0x74e0, 0x7cd6,
+	0x84db, 0x88c8, 0x8b34, 0x8e76, 0x90c1, 0x92f1, 0x94e9, 0x9ee3,
+	0xace7, 0xb0f2, 0xb8e5, 0xc0e8, 0xc8ec, 0xd0ea, 0xd8ef, 0xe08c,
+	0xe527, 0xeced, 0xf4f4, 0xfd03, 0x0505, 0x0707, 0x0d08, 0x183c,
+	0x1d0f, 0x26aa, 0x2826, 0x2cb2, 0x2ebf, 0x34eb, 0x3d3a, 0x4514,
+	0x4d19, 0x5509, 0x5d15, 0x6106, 0x650b, 0x6d13, 0x7d0e, 0x7f12,
+	0x813f, 0x8310, 0x8516, 0x8d62, 0x9965, 0xa15e, 0xa86f, 0xb118,
+	0xb30c, 0xb86d, 0xc10c, 0xc917, 0xd111, 0xd91e, 0xe10d, 0xe84e,
+	// Entry 100 - 13F
+	0xf11d, 0xf525, 0xf924, 0x0123, 0x0926, 0x112a, 0x192d, 0x2023,
+	0x2929, 0x312c, 0x3728, 0x3920, 0x3d2e, 0x4132, 0x4931, 0x4ec3,
+	0x551a, 0x646c, 0x747c, 0x7e80, 0x80a0, 0x8299, 0x8530, 0x9136,
+	0xa53e, 0xac37, 0xb537, 0xb938, 0xbd3c, 0xd941, 0xe543, 0xed5f,
+	0xef5f, 0xf658, 0xfd63, 0x7c20, 0x7ef5, 0x80f6, 0x82f7, 0x84f8,
+	0x86f9, 0x88fa, 0x8afb, 0x8cfc, 0x8e71, 0x90fe, 0x92ff, 0x9500,
+	0x9701, 0x9902, 0x9b44, 0x9d45, 0x9f46, 0xa147, 0xa348, 0xa549,
+	0xa74a, 0xa94b, 0xab4c, 0xad4d, 0xaf4e, 0xb14f, 0xb350, 0xb551,
+	// Entry 140 - 17F
+	0xb752, 0xb953, 0xbb54, 0xbd55, 0xbf56, 0xc157, 0xc358, 0xc559,
+	0xc75a, 0xc95b, 0xcb5c, 0xcd5d, 0xcf66,
+}
+
+// Size: 2128 bytes
+var variantIndex = map[string]uint8{
+	"1606nict": 0x0,
+	"1694acad": 0x1,
+	"1901":     0x2,
+	"1959acad": 0x3,
+	"1994":     0x67,
+	"1996":     0x4,
+	"abl1943":  0x5,
+	"akuapem":  0x6,
+	"alalc97":  0x69,
+	"aluku":    0x7,
+	"ao1990":   0x8,
+	"aranes":   0x9,
+	"arevela":  0xa,
+	"arevmda":  0xb,
+	"arkaika":  0xc,
+	"asante":   0xd,
+	"auvern":   0xe,
+	"baku1926": 0xf,
+	"balanka":  0x10,
+	"barla":    0x11,
+	"basiceng": 0x12,
+	"bauddha":  0x13,
+	"bciav":    0x14,
+	"bcizbl":   0x15,
+	"biscayan": 0x16,
+	"biske":    0x62,
+	"bohoric":  0x17,
+	"boont":    0x18,
+	"bornholm": 0x19,
+	"cisaup":   0x1a,
+	"colb1945": 0x1b,
+	"cornu":    0x1c,
+	"creiss":   0x1d,
+	"dajnko":   0x1e,
+	"ekavsk":   0x1f,
+	"emodeng":  0x20,
+	"fonipa":   0x6a,
+	"fonkirsh": 0x6b,
+	"fonnapa":  0x6c,
+	"fonupa":   0x6d,
+	"fonxsamp": 0x6e,
+	"gallo":    0x21,
+	"gascon":   0x22,
+	"grclass":  0x23,
+	"grital":   0x24,
+	"grmistr":  0x25,
+	"hepburn":  0x26,
+	"heploc":   0x68,
+	"hognorsk": 0x27,
+	"hsistemo": 0x28,
+	"ijekavsk": 0x29,
+	"itihasa":  0x2a,
+	"ivanchov": 0x2b,
+	"jauer":    0x2c,
+	"jyutping": 0x2d,
+	"kkcor":    0x2e,
+	"kociewie": 0x2f,
+	"kscor":    0x30,
+	"laukika":  0x31,
+	"lemosin":  0x32,
+	"lengadoc": 0x33,
+	"lipaw":    0x63,
+	"ltg1929":  0x34,
+	"ltg2007":  0x35,
+	"luna1918": 0x36,
+	"metelko":  0x37,
+	"monoton":  0x38,
+	"ndyuka":   0x39,
+	"nedis":    0x3a,
+	"newfound": 0x3b,
+	"nicard":   0x3c,
+	"njiva":    0x64,
+	"nulik":    0x3d,
+	"osojs":    0x65,
+	"oxendict": 0x3e,
+	"pahawh2":  0x3f,
+	"pahawh3":  0x40,
+	"pahawh4":  0x41,
+	"pamaka":   0x42,
+	"peano":    0x43,
+	"petr1708": 0x44,
+	"pinyin":   0x45,
+	"polyton":  0x46,
+	"provenc":  0x47,
+	"puter":    0x48,
+	"rigik":    0x49,
+	"rozaj":    0x4a,
+	"rumgr":    0x4b,
+	"scotland": 0x4c,
+	"scouse":   0x4d,
+	"simple":   0x6f,
+	"solba":    0x66,
+	"sotav":    0x4e,
+	"spanglis": 0x4f,
+	"surmiran": 0x50,
+	"sursilv":  0x51,
+	"sutsilv":  0x52,
+	"synnejyl": 0x53,
+	"tarask":   0x54,
+	"tongyong": 0x55,
+	"tunumiit": 0x56,
+	"uccor":    0x57,
+	"ucrcor":   0x58,
+	"ulster":   0x59,
+	"unifon":   0x5a,
+	"vaidika":  0x5b,
+	"valencia": 0x5c,
+	"vallader": 0x5d,
+	"vecdruka": 0x5e,
+	"vivaraup": 0x5f,
+	"wadegile": 0x60,
+	"xsistemo": 0x61,
+}
+
+// variantNumSpecialized is the number of specialized variants in variants.
+const variantNumSpecialized = 105
+
+// nRegionGroups is the number of region groups.
+const nRegionGroups = 33
+
+type likelyLangRegion struct {
+	lang   uint16
+	region uint16
+}
+
+// likelyScript is a lookup table, indexed by scriptID, for the most likely
+// languages and regions given a script.
+// Size: 1052 bytes, 263 elements
+var likelyScript = [263]likelyLangRegion{
+	1:   {lang: 0x14e, region: 0x85},
+	3:   {lang: 0x2a2, region: 0x107},
+	4:   {lang: 0x1f, region: 0x9a},
+	5:   {lang: 0x3a, region: 0x6c},
+	7:   {lang: 0x3b, region: 0x9d},
+	8:   {lang: 0x1d7, region: 0x28},
+	9:   {lang: 0x13, region: 0x9d},
+	10:  {lang: 0x5b, region: 0x96},
+	11:  {lang: 0x60, region: 0x52},
+	12:  {lang: 0xb9, region: 0xb5},
+	13:  {lang: 0x63, region: 0x96},
+	14:  {lang: 0xa5, region: 0x35},
+	15:  {lang: 0x3e9, region: 0x9a},
+	17:  {lang: 0x529, region: 0x12f},
+	18:  {lang: 0x3b1, region: 0x9a},
+	19:  {lang: 0x15e, region: 0x79},
+	20:  {lang: 0xc2, region: 0x96},
+	21:  {lang: 0x9d, region: 0xe8},
+	22:  {lang: 0xdb, region: 0x35},
+	23:  {lang: 0xf3, region: 0x49},
+	24:  {lang: 0x4f0, region: 0x12c},
+	25:  {lang: 0xe7, region: 0x13f},
+	26:  {lang: 0xe5, region: 0x136},
+	29:  {lang: 0xf1, region: 0x6c},
+	31:  {lang: 0x1a0, region: 0x5e},
+	32:  {lang: 0x3e2, region: 0x107},
+	34:  {lang: 0x1be, region: 0x9a},
+	38:  {lang: 0x15e, region: 0x79},
+	41:  {lang: 0x133, region: 0x6c},
+	42:  {lang: 0x431, region: 0x27},
+	44:  {lang: 0x27, region: 0x70},
+	46:  {lang: 0x210, region: 0x7e},
+	47:  {lang: 0xfe, region: 0x38},
+	49:  {lang: 0x19b, region: 0x9a},
+	50:  {lang: 0x19e, region: 0x131},
+	51:  {lang: 0x3e9, region: 0x9a},
+	52:  {lang: 0x136, region: 0x88},
+	53:  {lang: 0x1a4, region: 0x9a},
+	54:  {lang: 0x39d, region: 0x9a},
+	55:  {lang: 0x529, region: 0x12f},
+	56:  {lang: 0x254, region: 0xac},
+	57:  {lang: 0x529, region: 0x53},
+	58:  {lang: 0x1cb, region: 0xe8},
+	59:  {lang: 0x529, region: 0x53},
+	60:  {lang: 0x529, region: 0x12f},
+	61:  {lang: 0x2fd, region: 0x9c},
+	62:  {lang: 0x1bc, region: 0x98},
+	63:  {lang: 0x200, region: 0xa3},
+	64:  {lang: 0x1c5, region: 0x12c},
+	65:  {lang: 0x1ca, region: 0xb0},
+	68:  {lang: 0x1d5, region: 0x93},
+	70:  {lang: 0x142, region: 0x9f},
+	71:  {lang: 0x254, region: 0xac},
+	72:  {lang: 0x20e, region: 0x96},
+	73:  {lang: 0x200, region: 0xa3},
+	75:  {lang: 0x135, region: 0xc5},
+	76:  {lang: 0x200, region: 0xa3},
+	78:  {lang: 0x3bb, region: 0xe9},
+	79:  {lang: 0x24a, region: 0xa7},
+	80:  {lang: 0x3fa, region: 0x9a},
+	83:  {lang: 0x251, region: 0x9a},
+	84:  {lang: 0x254, region: 0xac},
+	86:  {lang: 0x88, region: 0x9a},
+	87:  {lang: 0x370, region: 0x124},
+	88:  {lang: 0x2b8, region: 0xb0},
+	93:  {lang: 0x29f, region: 0x9a},
+	94:  {lang: 0x2a8, region: 0x9a},
+	95:  {lang: 0x28f, region: 0x88},
+	96:  {lang: 0x1a0, region: 0x88},
+	97:  {lang: 0x2ac, region: 0x53},
+	99:  {lang: 0x4f4, region: 0x12c},
+	100: {lang: 0x4f5, region: 0x12c},
+	101: {lang: 0x1be, region: 0x9a},
+	103: {lang: 0x337, region: 0x9d},
+	104: {lang: 0x4f7, region: 0x53},
+	105: {lang: 0xa9, region: 0x53},
+	108: {lang: 0x2e8, region: 0x113},
+	109: {lang: 0x4f8, region: 0x10c},
+	110: {lang: 0x4f8, region: 0x10c},
+	111: {lang: 0x304, region: 0x9a},
+	112: {lang: 0x31b, region: 0x9a},
+	113: {lang: 0x30b, region: 0x53},
+	115: {lang: 0x31e, region: 0x35},
+	116: {lang: 0x30e, region: 0x9a},
+	117: {lang: 0x414, region: 0xe9},
+	118: {lang: 0x331, region: 0xc5},
+	121: {lang: 0x4f9, region: 0x109},
+	122: {lang: 0x3b, region: 0xa2},
+	123: {lang: 0x353, region: 0xdc},
+	126: {lang: 0x2d0, region: 0x85},
+	127: {lang: 0x52a, region: 0x53},
+	128: {lang: 0x403, region: 0x97},
+	129: {lang: 0x3ee, region: 0x9a},
+	130: {lang: 0x39b, region: 0xc6},
+	131: {lang: 0x395, region: 0x9a},
+	132: {lang: 0x399, region: 0x136},
+	133: {lang: 0x429, region: 0x116},
+	135: {lang: 0x3b, region: 0x11d},
+	136: {lang: 0xfd, region: 0xc5},
+	139: {lang: 0x27d, region: 0x107},
+	140: {lang: 0x2c9, region: 0x53},
+	141: {lang: 0x39f, region: 0x9d},
+	142: {lang: 0x39f, region: 0x53},
+	144: {lang: 0x3ad, region: 0xb1},
+	146: {lang: 0x1c6, region: 0x53},
+	147: {lang: 0x4fd, region: 0x9d},
+	200: {lang: 0x3cb, region: 0x96},
+	203: {lang: 0x372, region: 0x10d},
+	204: {lang: 0x420, region: 0x98},
+	206: {lang: 0x4ff, region: 0x15f},
+	207: {lang: 0x3f0, region: 0x9a},
+	208: {lang: 0x45, region: 0x136},
+	209: {lang: 0x139, region: 0x7c},
+	210: {lang: 0x3e9, region: 0x9a},
+	212: {lang: 0x3e9, region: 0x9a},
+	213: {lang: 0x3fa, region: 0x9a},
+	214: {lang: 0x40c, region: 0xb4},
+	217: {lang: 0x433, region: 0x9a},
+	218: {lang: 0xef, region: 0xc6},
+	219: {lang: 0x43e, region: 0x96},
+	221: {lang: 0x44d, region: 0x35},
+	222: {lang: 0x44e, region: 0x9c},
+	226: {lang: 0x45a, region: 0xe8},
+	227: {lang: 0x11a, region: 0x9a},
+	228: {lang: 0x45e, region: 0x53},
+	229: {lang: 0x232, region: 0x53},
+	230: {lang: 0x450, region: 0x9a},
+	231: {lang: 0x4a5, region: 0x53},
+	232: {lang: 0x9f, region: 0x13f},
+	233: {lang: 0x461, region: 0x9a},
+	235: {lang: 0x528, region: 0xbb},
+	236: {lang: 0x153, region: 0xe8},
+	237: {lang: 0x128, region: 0xce},
+	238: {lang: 0x46b, region: 0x124},
+	239: {lang: 0xa9, region: 0x53},
+	240: {lang: 0x2ce, region: 0x9a},
+	243: {lang: 0x4ad, region: 0x11d},
+	244: {lang: 0x4be, region: 0xb5},
+	247: {lang: 0x1ce, region: 0x9a},
+	250: {lang: 0x3a9, region: 0x9d},
+	251: {lang: 0x22, region: 0x9c},
+	253: {lang: 0x1ea, region: 0x53},
+	254: {lang: 0xef, region: 0xc6},
+}
+
+type likelyScriptRegion struct {
+	region uint16
+	script uint16
+	flags  uint8
+}
+
+// likelyLang is a lookup table, indexed by langID, for the most likely
+// scripts and regions given incomplete information. If more entries exist for a
+// given language, region and script are the index and size respectively
+// of the list in likelyLangList.
+// Size: 7980 bytes, 1330 elements
+var likelyLang = [1330]likelyScriptRegion{
+	0:    {region: 0x136, script: 0x5b, flags: 0x0},
+	1:    {region: 0x70, script: 0x5b, flags: 0x0},
+	2:    {region: 0x166, script: 0x5b, flags: 0x0},
+	3:    {region: 0x166, script: 0x5b, flags: 0x0},
+	4:    {region: 0x166, script: 0x5b, flags: 0x0},
+	5:    {region: 0x7e, script: 0x20, flags: 0x0},
+	6:    {region: 0x166, script: 0x5b, flags: 0x0},
+	7:    {region: 0x166, script: 0x20, flags: 0x0},
+	8:    {region: 0x81, script: 0x5b, flags: 0x0},
+	9:    {region: 0x166, script: 0x5b, flags: 0x0},
+	10:   {region: 0x166, script: 0x5b, flags: 0x0},
+	11:   {region: 0x166, script: 0x5b, flags: 0x0},
+	12:   {region: 0x96, script: 0x5b, flags: 0x0},
+	13:   {region: 0x132, script: 0x5b, flags: 0x0},
+	14:   {region: 0x81, script: 0x5b, flags: 0x0},
+	15:   {region: 0x166, script: 0x5b, flags: 0x0},
+	16:   {region: 0x166, script: 0x5b, flags: 0x0},
+	17:   {region: 0x107, script: 0x20, flags: 0x0},
+	18:   {region: 0x166, script: 0x5b, flags: 0x0},
+	19:   {region: 0x9d, script: 0x9, flags: 0x0},
+	20:   {region: 0x129, script: 0x5, flags: 0x0},
+	21:   {region: 0x166, script: 0x5b, flags: 0x0},
+	22:   {region: 0x162, script: 0x5b, flags: 0x0},
+	23:   {region: 0x166, script: 0x5b, flags: 0x0},
+	24:   {region: 0x166, script: 0x5b, flags: 0x0},
+	25:   {region: 0x166, script: 0x5b, flags: 0x0},
+	26:   {region: 0x166, script: 0x5b, flags: 0x0},
+	27:   {region: 0x166, script: 0x5b, flags: 0x0},
+	28:   {region: 0x52, script: 0x5b, flags: 0x0},
+	29:   {region: 0x166, script: 0x5b, flags: 0x0},
+	30:   {region: 0x166, script: 0x5b, flags: 0x0},
+	31:   {region: 0x9a, script: 0x4, flags: 0x0},
+	32:   {region: 0x166, script: 0x5b, flags: 0x0},
+	33:   {region: 0x81, script: 0x5b, flags: 0x0},
+	34:   {region: 0x9c, script: 0xfb, flags: 0x0},
+	35:   {region: 0x166, script: 0x5b, flags: 0x0},
+	36:   {region: 0x166, script: 0x5b, flags: 0x0},
+	37:   {region: 0x14e, script: 0x5b, flags: 0x0},
+	38:   {region: 0x107, script: 0x20, flags: 0x0},
+	39:   {region: 0x70, script: 0x2c, flags: 0x0},
+	40:   {region: 0x166, script: 0x5b, flags: 0x0},
+	41:   {region: 0x166, script: 0x5b, flags: 0x0},
+	42:   {region: 0xd7, script: 0x5b, flags: 0x0},
+	43:   {region: 0x166, script: 0x5b, flags: 0x0},
+	45:   {region: 0x166, script: 0x5b, flags: 0x0},
+	46:   {region: 0x166, script: 0x5b, flags: 0x0},
+	47:   {region: 0x166, script: 0x5b, flags: 0x0},
+	48:   {region: 0x166, script: 0x5b, flags: 0x0},
+	49:   {region: 0x166, script: 0x5b, flags: 0x0},
+	50:   {region: 0x166, script: 0x5b, flags: 0x0},
+	51:   {region: 0x96, script: 0x5b, flags: 0x0},
+	52:   {region: 0x166, script: 0x5, flags: 0x0},
+	53:   {region: 0x123, script: 0x5, flags: 0x0},
+	54:   {region: 0x166, script: 0x5b, flags: 0x0},
+	55:   {region: 0x166, script: 0x5b, flags: 0x0},
+	56:   {region: 0x166, script: 0x5b, flags: 0x0},
+	57:   {region: 0x166, script: 0x5b, flags: 0x0},
+	58:   {region: 0x6c, script: 0x5, flags: 0x0},
+	59:   {region: 0x0, script: 0x3, flags: 0x1},
+	60:   {region: 0x166, script: 0x5b, flags: 0x0},
+	61:   {region: 0x51, script: 0x5b, flags: 0x0},
+	62:   {region: 0x3f, script: 0x5b, flags: 0x0},
+	63:   {region: 0x68, script: 0x5, flags: 0x0},
+	65:   {region: 0xbb, script: 0x5, flags: 0x0},
+	66:   {region: 0x6c, script: 0x5, flags: 0x0},
+	67:   {region: 0x9a, script: 0xe, flags: 0x0},
+	68:   {region: 0x130, script: 0x5b, flags: 0x0},
+	69:   {region: 0x136, script: 0xd0, flags: 0x0},
+	70:   {region: 0x166, script: 0x5b, flags: 0x0},
+	71:   {region: 0x166, script: 0x5b, flags: 0x0},
+	72:   {region: 0x6f, script: 0x5b, flags: 0x0},
+	73:   {region: 0x166, script: 0x5b, flags: 0x0},
+	74:   {region: 0x166, script: 0x5b, flags: 0x0},
+	75:   {region: 0x49, script: 0x5b, flags: 0x0},
+	76:   {region: 0x166, script: 0x5b, flags: 0x0},
+	77:   {region: 0x107, script: 0x20, flags: 0x0},
+	78:   {region: 0x166, script: 0x5, flags: 0x0},
+	79:   {region: 0x166, script: 0x5b, flags: 0x0},
+	80:   {region: 0x166, script: 0x5b, flags: 0x0},
+	81:   {region: 0x166, script: 0x5b, flags: 0x0},
+	82:   {region: 0x9a, script: 0x22, flags: 0x0},
+	83:   {region: 0x166, script: 0x5b, flags: 0x0},
+	84:   {region: 0x166, script: 0x5b, flags: 0x0},
+	85:   {region: 0x166, script: 0x5b, flags: 0x0},
+	86:   {region: 0x3f, script: 0x5b, flags: 0x0},
+	87:   {region: 0x166, script: 0x5b, flags: 0x0},
+	88:   {region: 0x3, script: 0x5, flags: 0x1},
+	89:   {region: 0x107, script: 0x20, flags: 0x0},
+	90:   {region: 0xe9, script: 0x5, flags: 0x0},
+	91:   {region: 0x96, script: 0x5b, flags: 0x0},
+	92:   {region: 0xdc, script: 0x22, flags: 0x0},
+	93:   {region: 0x2e, script: 0x5b, flags: 0x0},
+	94:   {region: 0x52, script: 0x5b, flags: 0x0},
+	95:   {region: 0x166, script: 0x5b, flags: 0x0},
+	96:   {region: 0x52, script: 0xb, flags: 0x0},
+	97:   {region: 0x166, script: 0x5b, flags: 0x0},
+	98:   {region: 0x166, script: 0x5b, flags: 0x0},
+	99:   {region: 0x96, script: 0x5b, flags: 0x0},
+	100:  {region: 0x166, script: 0x5b, flags: 0x0},
+	101:  {region: 0x52, script: 0x5b, flags: 0x0},
+	102:  {region: 0x166, script: 0x5b, flags: 0x0},
+	103:  {region: 0x166, script: 0x5b, flags: 0x0},
+	104:  {region: 0x166, script: 0x5b, flags: 0x0},
+	105:  {region: 0x166, script: 0x5b, flags: 0x0},
+	106:  {region: 0x4f, script: 0x5b, flags: 0x0},
+	107:  {region: 0x166, script: 0x5b, flags: 0x0},
+	108:  {region: 0x166, script: 0x5b, flags: 0x0},
+	109:  {region: 0x166, script: 0x5b, flags: 0x0},
+	110:  {region: 0x166, script: 0x2c, flags: 0x0},
+	111:  {region: 0x166, script: 0x5b, flags: 0x0},
+	112:  {region: 0x166, script: 0x5b, flags: 0x0},
+	113:  {region: 0x47, script: 0x20, flags: 0x0},
+	114:  {region: 0x166, script: 0x5b, flags: 0x0},
+	115:  {region: 0x166, script: 0x5b, flags: 0x0},
+	116:  {region: 0x10c, script: 0x5, flags: 0x0},
+	117:  {region: 0x163, script: 0x5b, flags: 0x0},
+	118:  {region: 0x166, script: 0x5b, flags: 0x0},
+	119:  {region: 0x96, script: 0x5b, flags: 0x0},
+	120:  {region: 0x166, script: 0x5b, flags: 0x0},
+	121:  {region: 0x130, script: 0x5b, flags: 0x0},
+	122:  {region: 0x52, script: 0x5b, flags: 0x0},
+	123:  {region: 0x9a, script: 0xe6, flags: 0x0},
+	124:  {region: 0xe9, script: 0x5, flags: 0x0},
+	125:  {region: 0x9a, script: 0x22, flags: 0x0},
+	126:  {region: 0x38, script: 0x20, flags: 0x0},
+	127:  {region: 0x9a, script: 0x22, flags: 0x0},
+	128:  {region: 0xe9, script: 0x5, flags: 0x0},
+	129:  {region: 0x12c, script: 0x34, flags: 0x0},
+	131:  {region: 0x9a, script: 0x22, flags: 0x0},
+	132:  {region: 0x166, script: 0x5b, flags: 0x0},
+	133:  {region: 0x9a, script: 0x22, flags: 0x0},
+	134:  {region: 0xe8, script: 0x5b, flags: 0x0},
+	135:  {region: 0x166, script: 0x5b, flags: 0x0},
+	136:  {region: 0x9a, script: 0x22, flags: 0x0},
+	137:  {region: 0x166, script: 0x5b, flags: 0x0},
+	138:  {region: 0x140, script: 0x5b, flags: 0x0},
+	139:  {region: 0x166, script: 0x5b, flags: 0x0},
+	140:  {region: 0x166, script: 0x5b, flags: 0x0},
+	141:  {region: 0xe8, script: 0x5b, flags: 0x0},
+	142:  {region: 0x166, script: 0x5b, flags: 0x0},
+	143:  {region: 0xd7, script: 0x5b, flags: 0x0},
+	144:  {region: 0x166, script: 0x5b, flags: 0x0},
+	145:  {region: 0x166, script: 0x5b, flags: 0x0},
+	146:  {region: 0x166, script: 0x5b, flags: 0x0},
+	147:  {region: 0x166, script: 0x2c, flags: 0x0},
+	148:  {region: 0x9a, script: 0x22, flags: 0x0},
+	149:  {region: 0x96, script: 0x5b, flags: 0x0},
+	150:  {region: 0x166, script: 0x5b, flags: 0x0},
+	151:  {region: 0x166, script: 0x5b, flags: 0x0},
+	152:  {region: 0x115, script: 0x5b, flags: 0x0},
+	153:  {region: 0x166, script: 0x5b, flags: 0x0},
+	154:  {region: 0x166, script: 0x5b, flags: 0x0},
+	155:  {region: 0x52, script: 0x5b, flags: 0x0},
+	156:  {region: 0x166, script: 0x5b, flags: 0x0},
+	157:  {region: 0xe8, script: 0x5b, flags: 0x0},
+	158:  {region: 0x166, script: 0x5b, flags: 0x0},
+	159:  {region: 0x13f, script: 0xe8, flags: 0x0},
+	160:  {region: 0xc4, script: 0x5b, flags: 0x0},
+	161:  {region: 0x166, script: 0x5b, flags: 0x0},
+	162:  {region: 0x166, script: 0x5b, flags: 0x0},
+	163:  {region: 0xc4, script: 0x5b, flags: 0x0},
+	164:  {region: 0x166, script: 0x5b, flags: 0x0},
+	165:  {region: 0x35, script: 0xe, flags: 0x0},
+	166:  {region: 0x166, script: 0x5b, flags: 0x0},
+	167:  {region: 0x166, script: 0x5b, flags: 0x0},
+	168:  {region: 0x166, script: 0x5b, flags: 0x0},
+	169:  {region: 0x53, script: 0xef, flags: 0x0},
+	170:  {region: 0x166, script: 0x5b, flags: 0x0},
+	171:  {region: 0x166, script: 0x5b, flags: 0x0},
+	172:  {region: 0x166, script: 0x5b, flags: 0x0},
+	173:  {region: 0x9a, script: 0xe, flags: 0x0},
+	174:  {region: 0x166, script: 0x5b, flags: 0x0},
+	175:  {region: 0x9d, script: 0x5, flags: 0x0},
+	176:  {region: 0x166, script: 0x5b, flags: 0x0},
+	177:  {region: 0x4f, script: 0x5b, flags: 0x0},
+	178:  {region: 0x79, script: 0x5b, flags: 0x0},
+	179:  {region: 0x9a, script: 0x22, flags: 0x0},
+	180:  {region: 0xe9, script: 0x5, flags: 0x0},
+	181:  {region: 0x9a, script: 0x22, flags: 0x0},
+	182:  {region: 0x166, script: 0x5b, flags: 0x0},
+	183:  {region: 0x33, script: 0x5b, flags: 0x0},
+	184:  {region: 0x166, script: 0x5b, flags: 0x0},
+	185:  {region: 0xb5, script: 0xc, flags: 0x0},
+	186:  {region: 0x52, script: 0x5b, flags: 0x0},
+	187:  {region: 0x166, script: 0x2c, flags: 0x0},
+	188:  {region: 0xe8, script: 0x5b, flags: 0x0},
+	189:  {region: 0x166, script: 0x5b, flags: 0x0},
+	190:  {region: 0xe9, script: 0x22, flags: 0x0},
+	191:  {region: 0x107, script: 0x20, flags: 0x0},
+	192:  {region: 0x160, script: 0x5b, flags: 0x0},
+	193:  {region: 0x166, script: 0x5b, flags: 0x0},
+	194:  {region: 0x96, script: 0x5b, flags: 0x0},
+	195:  {region: 0x166, script: 0x5b, flags: 0x0},
+	196:  {region: 0x52, script: 0x5b, flags: 0x0},
+	197:  {region: 0x166, script: 0x5b, flags: 0x0},
+	198:  {region: 0x166, script: 0x5b, flags: 0x0},
+	199:  {region: 0x166, script: 0x5b, flags: 0x0},
+	200:  {region: 0x87, script: 0x5b, flags: 0x0},
+	201:  {region: 0x166, script: 0x5b, flags: 0x0},
+	202:  {region: 0x166, script: 0x5b, flags: 0x0},
+	203:  {region: 0x166, script: 0x5b, flags: 0x0},
+	204:  {region: 0x166, script: 0x5b, flags: 0x0},
+	205:  {region: 0x6e, script: 0x2c, flags: 0x0},
+	206:  {region: 0x166, script: 0x5b, flags: 0x0},
+	207:  {region: 0x166, script: 0x5b, flags: 0x0},
+	208:  {region: 0x52, script: 0x5b, flags: 0x0},
+	209:  {region: 0x166, script: 0x5b, flags: 0x0},
+	210:  {region: 0x166, script: 0x5b, flags: 0x0},
+	211:  {region: 0xc4, script: 0x5b, flags: 0x0},
+	212:  {region: 0x166, script: 0x5b, flags: 0x0},
+	213:  {region: 0x166, script: 0x5b, flags: 0x0},
+	214:  {region: 0x166, script: 0x5b, flags: 0x0},
+	215:  {region: 0x6f, script: 0x5b, flags: 0x0},
+	216:  {region: 0x166, script: 0x5b, flags: 0x0},
+	217:  {region: 0x166, script: 0x5b, flags: 0x0},
+	218:  {region: 0xd7, script: 0x5b, flags: 0x0},
+	219:  {region: 0x35, script: 0x16, flags: 0x0},
+	220:  {region: 0x107, script: 0x20, flags: 0x0},
+	221:  {region: 0xe8, script: 0x5b, flags: 0x0},
+	222:  {region: 0x166, script: 0x5b, flags: 0x0},
+	223:  {region: 0x132, script: 0x5b, flags: 0x0},
+	224:  {region: 0x8b, script: 0x5b, flags: 0x0},
+	225:  {region: 0x76, script: 0x5b, flags: 0x0},
+	226:  {region: 0x107, script: 0x20, flags: 0x0},
+	227:  {region: 0x136, script: 0x5b, flags: 0x0},
+	228:  {region: 0x49, script: 0x5b, flags: 0x0},
+	229:  {region: 0x136, script: 0x1a, flags: 0x0},
+	230:  {region: 0xa7, script: 0x5, flags: 0x0},
+	231:  {region: 0x13f, script: 0x19, flags: 0x0},
+	232:  {region: 0x166, script: 0x5b, flags: 0x0},
+	233:  {region: 0x9c, script: 0x5, flags: 0x0},
+	234:  {region: 0x166, script: 0x5b, flags: 0x0},
+	235:  {region: 0x166, script: 0x5b, flags: 0x0},
+	236:  {region: 0x166, script: 0x5b, flags: 0x0},
+	237:  {region: 0x166, script: 0x5b, flags: 0x0},
+	238:  {region: 0x166, script: 0x5b, flags: 0x0},
+	239:  {region: 0xc6, script: 0xda, flags: 0x0},
+	240:  {region: 0x79, script: 0x5b, flags: 0x0},
+	241:  {region: 0x6c, script: 0x1d, flags: 0x0},
+	242:  {region: 0xe8, script: 0x5b, flags: 0x0},
+	243:  {region: 0x49, script: 0x17, flags: 0x0},
+	244:  {region: 0x131, script: 0x20, flags: 0x0},
+	245:  {region: 0x49, script: 0x17, flags: 0x0},
+	246:  {region: 0x49, script: 0x17, flags: 0x0},
+	247:  {region: 0x49, script: 0x17, flags: 0x0},
+	248:  {region: 0x49, script: 0x17, flags: 0x0},
+	249:  {region: 0x10b, script: 0x5b, flags: 0x0},
+	250:  {region: 0x5f, script: 0x5b, flags: 0x0},
+	251:  {region: 0xea, script: 0x5b, flags: 0x0},
+	252:  {region: 0x49, script: 0x17, flags: 0x0},
+	253:  {region: 0xc5, script: 0x88, flags: 0x0},
+	254:  {region: 0x8, script: 0x2, flags: 0x1},
+	255:  {region: 0x107, script: 0x20, flags: 0x0},
+	256:  {region: 0x7c, script: 0x5b, flags: 0x0},
+	257:  {region: 0x64, script: 0x5b, flags: 0x0},
+	258:  {region: 0x166, script: 0x5b, flags: 0x0},
+	259:  {region: 0x166, script: 0x5b, flags: 0x0},
+	260:  {region: 0x166, script: 0x5b, flags: 0x0},
+	261:  {region: 0x166, script: 0x5b, flags: 0x0},
+	262:  {region: 0x136, script: 0x5b, flags: 0x0},
+	263:  {region: 0x107, script: 0x20, flags: 0x0},
+	264:  {region: 0xa5, script: 0x5b, flags: 0x0},
+	265:  {region: 0x166, script: 0x5b, flags: 0x0},
+	266:  {region: 0x166, script: 0x5b, flags: 0x0},
+	267:  {region: 0x9a, script: 0x5, flags: 0x0},
+	268:  {region: 0x166, script: 0x5b, flags: 0x0},
+	269:  {region: 0x61, script: 0x5b, flags: 0x0},
+	270:  {region: 0x166, script: 0x5b, flags: 0x0},
+	271:  {region: 0x49, script: 0x5b, flags: 0x0},
+	272:  {region: 0x166, script: 0x5b, flags: 0x0},
+	273:  {region: 0x166, script: 0x5b, flags: 0x0},
+	274:  {region: 0x166, script: 0x5b, flags: 0x0},
+	275:  {region: 0x166, script: 0x5, flags: 0x0},
+	276:  {region: 0x49, script: 0x5b, flags: 0x0},
+	277:  {region: 0x166, script: 0x5b, flags: 0x0},
+	278:  {region: 0x166, script: 0x5b, flags: 0x0},
+	279:  {region: 0xd5, script: 0x5b, flags: 0x0},
+	280:  {region: 0x4f, script: 0x5b, flags: 0x0},
+	281:  {region: 0x166, script: 0x5b, flags: 0x0},
+	282:  {region: 0x9a, script: 0x5, flags: 0x0},
+	283:  {region: 0x166, script: 0x5b, flags: 0x0},
+	284:  {region: 0x166, script: 0x5b, flags: 0x0},
+	285:  {region: 0x166, script: 0x5b, flags: 0x0},
+	286:  {region: 0x166, script: 0x2c, flags: 0x0},
+	287:  {region: 0x61, script: 0x5b, flags: 0x0},
+	288:  {region: 0xc4, script: 0x5b, flags: 0x0},
+	289:  {region: 0xd1, script: 0x5b, flags: 0x0},
+	290:  {region: 0x166, script: 0x5b, flags: 0x0},
+	291:  {region: 0xdc, script: 0x22, flags: 0x0},
+	292:  {region: 0x52, script: 0x5b, flags: 0x0},
+	293:  {region: 0x166, script: 0x5b, flags: 0x0},
+	294:  {region: 0x166, script: 0x5b, flags: 0x0},
+	295:  {region: 0x166, script: 0x5b, flags: 0x0},
+	296:  {region: 0xce, script: 0xed, flags: 0x0},
+	297:  {region: 0x166, script: 0x5b, flags: 0x0},
+	298:  {region: 0x166, script: 0x5b, flags: 0x0},
+	299:  {region: 0x115, script: 0x5b, flags: 0x0},
+	300:  {region: 0x37, script: 0x5b, flags: 0x0},
+	301:  {region: 0x43, script: 0xef, flags: 0x0},
+	302:  {region: 0x166, script: 0x5b, flags: 0x0},
+	303:  {region: 0xa5, script: 0x5b, flags: 0x0},
+	304:  {region: 0x81, script: 0x5b, flags: 0x0},
+	305:  {region: 0xd7, script: 0x5b, flags: 0x0},
+	306:  {region: 0x9f, script: 0x5b, flags: 0x0},
+	307:  {region: 0x6c, script: 0x29, flags: 0x0},
+	308:  {region: 0x166, script: 0x5b, flags: 0x0},
+	309:  {region: 0xc5, script: 0x4b, flags: 0x0},
+	310:  {region: 0x88, script: 0x34, flags: 0x0},
+	311:  {region: 0x166, script: 0x5b, flags: 0x0},
+	312:  {region: 0x166, script: 0x5b, flags: 0x0},
+	313:  {region: 0xa, script: 0x2, flags: 0x1},
+	314:  {region: 0x166, script: 0x5b, flags: 0x0},
+	315:  {region: 0x166, script: 0x5b, flags: 0x0},
+	316:  {region: 0x1, script: 0x5b, flags: 0x0},
+	317:  {region: 0x166, script: 0x5b, flags: 0x0},
+	318:  {region: 0x6f, script: 0x5b, flags: 0x0},
+	319:  {region: 0x136, script: 0x5b, flags: 0x0},
+	320:  {region: 0x6b, script: 0x5b, flags: 0x0},
+	321:  {region: 0x166, script: 0x5b, flags: 0x0},
+	322:  {region: 0x9f, script: 0x46, flags: 0x0},
+	323:  {region: 0x166, script: 0x5b, flags: 0x0},
+	324:  {region: 0x166, script: 0x5b, flags: 0x0},
+	325:  {region: 0x6f, script: 0x5b, flags: 0x0},
+	326:  {region: 0x52, script: 0x5b, flags: 0x0},
+	327:  {region: 0x6f, script: 0x5b, flags: 0x0},
+	328:  {region: 0x9d, script: 0x5, flags: 0x0},
+	329:  {region: 0x166, script: 0x5b, flags: 0x0},
+	330:  {region: 0x166, script: 0x5b, flags: 0x0},
+	331:  {region: 0x166, script: 0x5b, flags: 0x0},
+	332:  {region: 0x166, script: 0x5b, flags: 0x0},
+	333:  {region: 0x87, script: 0x5b, flags: 0x0},
+	334:  {region: 0xc, script: 0x2, flags: 0x1},
+	335:  {region: 0x166, script: 0x5b, flags: 0x0},
+	336:  {region: 0xc4, script: 0x5b, flags: 0x0},
+	337:  {region: 0x73, script: 0x5b, flags: 0x0},
+	338:  {region: 0x10c, script: 0x5, flags: 0x0},
+	339:  {region: 0xe8, script: 0x5b, flags: 0x0},
+	340:  {region: 0x10d, script: 0x5b, flags: 0x0},
+	341:  {region: 0x74, script: 0x5b, flags: 0x0},
+	342:  {region: 0x166, script: 0x5b, flags: 0x0},
+	343:  {region: 0x166, script: 0x5b, flags: 0x0},
+	344:  {region: 0x77, script: 0x5b, flags: 0x0},
+	345:  {region: 0x166, script: 0x5b, flags: 0x0},
+	346:  {region: 0x3b, script: 0x5b, flags: 0x0},
+	347:  {region: 0x166, script: 0x5b, flags: 0x0},
+	348:  {region: 0x166, script: 0x5b, flags: 0x0},
+	349:  {region: 0x166, script: 0x5b, flags: 0x0},
+	350:  {region: 0x79, script: 0x5b, flags: 0x0},
+	351:  {region: 0x136, script: 0x5b, flags: 0x0},
+	352:  {region: 0x79, script: 0x5b, flags: 0x0},
+	353:  {region: 0x61, script: 0x5b, flags: 0x0},
+	354:  {region: 0x61, script: 0x5b, flags: 0x0},
+	355:  {region: 0x52, script: 0x5, flags: 0x0},
+	356:  {region: 0x141, script: 0x5b, flags: 0x0},
+	357:  {region: 0x166, script: 0x5b, flags: 0x0},
+	358:  {region: 0x85, script: 0x5b, flags: 0x0},
+	359:  {region: 0x166, script: 0x5b, flags: 0x0},
+	360:  {region: 0xd5, script: 0x5b, flags: 0x0},
+	361:  {region: 0x9f, script: 0x5b, flags: 0x0},
+	362:  {region: 0xd7, script: 0x5b, flags: 0x0},
+	363:  {region: 0x166, script: 0x5b, flags: 0x0},
+	364:  {region: 0x10c, script: 0x5b, flags: 0x0},
+	365:  {region: 0xda, script: 0x5b, flags: 0x0},
+	366:  {region: 0x97, script: 0x5b, flags: 0x0},
+	367:  {region: 0x81, script: 0x5b, flags: 0x0},
+	368:  {region: 0x166, script: 0x5b, flags: 0x0},
+	369:  {region: 0xbd, script: 0x5b, flags: 0x0},
+	370:  {region: 0x166, script: 0x5b, flags: 0x0},
+	371:  {region: 0x166, script: 0x5b, flags: 0x0},
+	372:  {region: 0x166, script: 0x5b, flags: 0x0},
+	373:  {region: 0x53, script: 0x3b, flags: 0x0},
+	374:  {region: 0x166, script: 0x5b, flags: 0x0},
+	375:  {region: 0x96, script: 0x5b, flags: 0x0},
+	376:  {region: 0x166, script: 0x5b, flags: 0x0},
+	377:  {region: 0x166, script: 0x5b, flags: 0x0},
+	378:  {region: 0x9a, script: 0x22, flags: 0x0},
+	379:  {region: 0x166, script: 0x5b, flags: 0x0},
+	380:  {region: 0x9d, script: 0x5, flags: 0x0},
+	381:  {region: 0x7f, script: 0x5b, flags: 0x0},
+	382:  {region: 0x7c, script: 0x5b, flags: 0x0},
+	383:  {region: 0x166, script: 0x5b, flags: 0x0},
+	384:  {region: 0x166, script: 0x5b, flags: 0x0},
+	385:  {region: 0x166, script: 0x5b, flags: 0x0},
+	386:  {region: 0x166, script: 0x5b, flags: 0x0},
+	387:  {region: 0x166, script: 0x5b, flags: 0x0},
+	388:  {region: 0x166, script: 0x5b, flags: 0x0},
+	389:  {region: 0x70, script: 0x2c, flags: 0x0},
+	390:  {region: 0x166, script: 0x5b, flags: 0x0},
+	391:  {region: 0xdc, script: 0x22, flags: 0x0},
+	392:  {region: 0x166, script: 0x5b, flags: 0x0},
+	393:  {region: 0xa8, script: 0x5b, flags: 0x0},
+	394:  {region: 0x166, script: 0x5b, flags: 0x0},
+	395:  {region: 0xe9, script: 0x5, flags: 0x0},
+	396:  {region: 0x166, script: 0x5b, flags: 0x0},
+	397:  {region: 0xe9, script: 0x5, flags: 0x0},
+	398:  {region: 0x166, script: 0x5b, flags: 0x0},
+	399:  {region: 0x166, script: 0x5b, flags: 0x0},
+	400:  {region: 0x6f, script: 0x5b, flags: 0x0},
+	401:  {region: 0x9d, script: 0x5, flags: 0x0},
+	402:  {region: 0x166, script: 0x5b, flags: 0x0},
+	403:  {region: 0x166, script: 0x2c, flags: 0x0},
+	404:  {region: 0xf2, script: 0x5b, flags: 0x0},
+	405:  {region: 0x166, script: 0x5b, flags: 0x0},
+	406:  {region: 0x166, script: 0x5b, flags: 0x0},
+	407:  {region: 0x166, script: 0x5b, flags: 0x0},
+	408:  {region: 0x166, script: 0x2c, flags: 0x0},
+	409:  {region: 0x166, script: 0x5b, flags: 0x0},
+	410:  {region: 0x9a, script: 0x22, flags: 0x0},
+	411:  {region: 0x9a, script: 0xe9, flags: 0x0},
+	412:  {region: 0x96, script: 0x5b, flags: 0x0},
+	413:  {region: 0xda, script: 0x5b, flags: 0x0},
+	414:  {region: 0x131, script: 0x32, flags: 0x0},
+	415:  {region: 0x166, script: 0x5b, flags: 0x0},
+	416:  {region: 0xe, script: 0x2, flags: 0x1},
+	417:  {region: 0x9a, script: 0xe, flags: 0x0},
+	418:  {region: 0x166, script: 0x5b, flags: 0x0},
+	419:  {region: 0x4e, script: 0x5b, flags: 0x0},
+	420:  {region: 0x9a, script: 0x35, flags: 0x0},
+	421:  {region: 0x41, script: 0x5b, flags: 0x0},
+	422:  {region: 0x54, script: 0x5b, flags: 0x0},
+	423:  {region: 0x166, script: 0x5b, flags: 0x0},
+	424:  {region: 0x81, script: 0x5b, flags: 0x0},
+	425:  {region: 0x166, script: 0x5b, flags: 0x0},
+	426:  {region: 0x166, script: 0x5b, flags: 0x0},
+	427:  {region: 0xa5, script: 0x5b, flags: 0x0},
+	428:  {region: 0x99, script: 0x5b, flags: 0x0},
+	429:  {region: 0x166, script: 0x5b, flags: 0x0},
+	430:  {region: 0xdc, script: 0x22, flags: 0x0},
+	431:  {region: 0x166, script: 0x5b, flags: 0x0},
+	432:  {region: 0x166, script: 0x5, flags: 0x0},
+	433:  {region: 0x49, script: 0x5b, flags: 0x0},
+	434:  {region: 0x166, script: 0x5, flags: 0x0},
+	435:  {region: 0x166, script: 0x5b, flags: 0x0},
+	436:  {region: 0x10, script: 0x3, flags: 0x1},
+	437:  {region: 0x166, script: 0x5b, flags: 0x0},
+	438:  {region: 0x53, script: 0x3b, flags: 0x0},
+	439:  {region: 0x166, script: 0x5b, flags: 0x0},
+	440:  {region: 0x136, script: 0x5b, flags: 0x0},
+	441:  {region: 0x24, script: 0x5, flags: 0x0},
+	442:  {region: 0x166, script: 0x5b, flags: 0x0},
+	443:  {region: 0x166, script: 0x2c, flags: 0x0},
+	444:  {region: 0x98, script: 0x3e, flags: 0x0},
+	445:  {region: 0x166, script: 0x5b, flags: 0x0},
+	446:  {region: 0x9a, script: 0x22, flags: 0x0},
+	447:  {region: 0x166, script: 0x5b, flags: 0x0},
+	448:  {region: 0x74, script: 0x5b, flags: 0x0},
+	449:  {region: 0x166, script: 0x5b, flags: 0x0},
+	450:  {region: 0x166, script: 0x5b, flags: 0x0},
+	451:  {region: 0xe8, script: 0x5b, flags: 0x0},
+	452:  {region: 0x166, script: 0x5b, flags: 0x0},
+	453:  {region: 0x12c, script: 0x40, flags: 0x0},
+	454:  {region: 0x53, script: 0x92, flags: 0x0},
+	455:  {region: 0x166, script: 0x5b, flags: 0x0},
+	456:  {region: 0xe9, script: 0x5, flags: 0x0},
+	457:  {region: 0x9a, script: 0x22, flags: 0x0},
+	458:  {region: 0xb0, script: 0x41, flags: 0x0},
+	459:  {region: 0xe8, script: 0x5b, flags: 0x0},
+	460:  {region: 0xe9, script: 0x5, flags: 0x0},
+	461:  {region: 0xe7, script: 0x5b, flags: 0x0},
+	462:  {region: 0x9a, script: 0x22, flags: 0x0},
+	463:  {region: 0x9a, script: 0x22, flags: 0x0},
+	464:  {region: 0x166, script: 0x5b, flags: 0x0},
+	465:  {region: 0x91, script: 0x5b, flags: 0x0},
+	466:  {region: 0x61, script: 0x5b, flags: 0x0},
+	467:  {region: 0x53, script: 0x3b, flags: 0x0},
+	468:  {region: 0x92, script: 0x5b, flags: 0x0},
+	469:  {region: 0x93, script: 0x5b, flags: 0x0},
+	470:  {region: 0x166, script: 0x5b, flags: 0x0},
+	471:  {region: 0x28, script: 0x8, flags: 0x0},
+	472:  {region: 0xd3, script: 0x5b, flags: 0x0},
+	473:  {region: 0x79, script: 0x5b, flags: 0x0},
+	474:  {region: 0x166, script: 0x5b, flags: 0x0},
+	475:  {region: 0x166, script: 0x5b, flags: 0x0},
+	476:  {region: 0xd1, script: 0x5b, flags: 0x0},
+	477:  {region: 0xd7, script: 0x5b, flags: 0x0},
+	478:  {region: 0x166, script: 0x5b, flags: 0x0},
+	479:  {region: 0x166, script: 0x5b, flags: 0x0},
+	480:  {region: 0x166, script: 0x5b, flags: 0x0},
+	481:  {region: 0x96, script: 0x5b, flags: 0x0},
+	482:  {region: 0x166, script: 0x5b, flags: 0x0},
+	483:  {region: 0x166, script: 0x5b, flags: 0x0},
+	484:  {region: 0x166, script: 0x5b, flags: 0x0},
+	486:  {region: 0x123, script: 0x5b, flags: 0x0},
+	487:  {region: 0xd7, script: 0x5b, flags: 0x0},
+	488:  {region: 0x166, script: 0x5b, flags: 0x0},
+	489:  {region: 0x166, script: 0x5b, flags: 0x0},
+	490:  {region: 0x53, script: 0xfd, flags: 0x0},
+	491:  {region: 0x166, script: 0x5b, flags: 0x0},
+	492:  {region: 0x136, script: 0x5b, flags: 0x0},
+	493:  {region: 0x166, script: 0x5b, flags: 0x0},
+	494:  {region: 0x49, script: 0x5b, flags: 0x0},
+	495:  {region: 0x166, script: 0x5b, flags: 0x0},
+	496:  {region: 0x166, script: 0x5b, flags: 0x0},
+	497:  {region: 0xe8, script: 0x5b, flags: 0x0},
+	498:  {region: 0x166, script: 0x5b, flags: 0x0},
+	499:  {region: 0x96, script: 0x5b, flags: 0x0},
+	500:  {region: 0x107, script: 0x20, flags: 0x0},
+	501:  {region: 0x1, script: 0x5b, flags: 0x0},
+	502:  {region: 0x166, script: 0x5b, flags: 0x0},
+	503:  {region: 0x166, script: 0x5b, flags: 0x0},
+	504:  {region: 0x9e, script: 0x5b, flags: 0x0},
+	505:  {region: 0x9f, script: 0x5b, flags: 0x0},
+	506:  {region: 0x49, script: 0x17, flags: 0x0},
+	507:  {region: 0x98, script: 0x3e, flags: 0x0},
+	508:  {region: 0x166, script: 0x5b, flags: 0x0},
+	509:  {region: 0x166, script: 0x5b, flags: 0x0},
+	510:  {region: 0x107, script: 0x5b, flags: 0x0},
+	511:  {region: 0x166, script: 0x5b, flags: 0x0},
+	512:  {region: 0xa3, script: 0x49, flags: 0x0},
+	513:  {region: 0x166, script: 0x5b, flags: 0x0},
+	514:  {region: 0xa1, script: 0x5b, flags: 0x0},
+	515:  {region: 0x1, script: 0x5b, flags: 0x0},
+	516:  {region: 0x166, script: 0x5b, flags: 0x0},
+	517:  {region: 0x166, script: 0x5b, flags: 0x0},
+	518:  {region: 0x166, script: 0x5b, flags: 0x0},
+	519:  {region: 0x52, script: 0x5b, flags: 0x0},
+	520:  {region: 0x131, script: 0x3e, flags: 0x0},
+	521:  {region: 0x166, script: 0x5b, flags: 0x0},
+	522:  {region: 0x130, script: 0x5b, flags: 0x0},
+	523:  {region: 0xdc, script: 0x22, flags: 0x0},
+	524:  {region: 0x166, script: 0x5b, flags: 0x0},
+	525:  {region: 0x64, script: 0x5b, flags: 0x0},
+	526:  {region: 0x96, script: 0x5b, flags: 0x0},
+	527:  {region: 0x96, script: 0x5b, flags: 0x0},
+	528:  {region: 0x7e, script: 0x2e, flags: 0x0},
+	529:  {region: 0x138, script: 0x20, flags: 0x0},
+	530:  {region: 0x68, script: 0x5b, flags: 0x0},
+	531:  {region: 0xc5, script: 0x5b, flags: 0x0},
+	532:  {region: 0x166, script: 0x5b, flags: 0x0},
+	533:  {region: 0x166, script: 0x5b, flags: 0x0},
+	534:  {region: 0xd7, script: 0x5b, flags: 0x0},
+	535:  {region: 0xa5, script: 0x5b, flags: 0x0},
+	536:  {region: 0xc4, script: 0x5b, flags: 0x0},
+	537:  {region: 0x107, script: 0x20, flags: 0x0},
+	538:  {region: 0x166, script: 0x5b, flags: 0x0},
+	539:  {region: 0x166, script: 0x5b, flags: 0x0},
+	540:  {region: 0x166, script: 0x5b, flags: 0x0},
+	541:  {region: 0x166, script: 0x5b, flags: 0x0},
+	542:  {region: 0xd5, script: 0x5, flags: 0x0},
+	543:  {region: 0xd7, script: 0x5b, flags: 0x0},
+	544:  {region: 0x165, script: 0x5b, flags: 0x0},
+	545:  {region: 0x166, script: 0x5b, flags: 0x0},
+	546:  {region: 0x166, script: 0x5b, flags: 0x0},
+	547:  {region: 0x130, script: 0x5b, flags: 0x0},
+	548:  {region: 0x123, script: 0x5, flags: 0x0},
+	549:  {region: 0x166, script: 0x5b, flags: 0x0},
+	550:  {region: 0x124, script: 0xee, flags: 0x0},
+	551:  {region: 0x5b, script: 0x5b, flags: 0x0},
+	552:  {region: 0x52, script: 0x5b, flags: 0x0},
+	553:  {region: 0x166, script: 0x5b, flags: 0x0},
+	554:  {region: 0x4f, script: 0x5b, flags: 0x0},
+	555:  {region: 0x9a, script: 0x22, flags: 0x0},
+	556:  {region: 0x9a, script: 0x22, flags: 0x0},
+	557:  {region: 0x4b, script: 0x5b, flags: 0x0},
+	558:  {region: 0x96, script: 0x5b, flags: 0x0},
+	559:  {region: 0x166, script: 0x5b, flags: 0x0},
+	560:  {region: 0x41, script: 0x5b, flags: 0x0},
+	561:  {region: 0x9a, script: 0x5b, flags: 0x0},
+	562:  {region: 0x53, script: 0xe5, flags: 0x0},
+	563:  {region: 0x9a, script: 0x22, flags: 0x0},
+	564:  {region: 0xc4, script: 0x5b, flags: 0x0},
+	565:  {region: 0x166, script: 0x5b, flags: 0x0},
+	566:  {region: 0x9a, script: 0x76, flags: 0x0},
+	567:  {region: 0xe9, script: 0x5, flags: 0x0},
+	568:  {region: 0x166, script: 0x5b, flags: 0x0},
+	569:  {region: 0xa5, script: 0x5b, flags: 0x0},
+	570:  {region: 0x166, script: 0x5b, flags: 0x0},
+	571:  {region: 0x12c, script: 0x5b, flags: 0x0},
+	572:  {region: 0x166, script: 0x5b, flags: 0x0},
+	573:  {region: 0xd3, script: 0x5b, flags: 0x0},
+	574:  {region: 0x166, script: 0x5b, flags: 0x0},
+	575:  {region: 0xb0, script: 0x58, flags: 0x0},
+	576:  {region: 0x166, script: 0x5b, flags: 0x0},
+	577:  {region: 0x166, script: 0x5b, flags: 0x0},
+	578:  {region: 0x13, script: 0x6, flags: 0x1},
+	579:  {region: 0x166, script: 0x5b, flags: 0x0},
+	580:  {region: 0x52, script: 0x5b, flags: 0x0},
+	581:  {region: 0x83, script: 0x5b, flags: 0x0},
+	582:  {region: 0xa5, script: 0x5b, flags: 0x0},
+	583:  {region: 0x166, script: 0x5b, flags: 0x0},
+	584:  {region: 0x166, script: 0x5b, flags: 0x0},
+	585:  {region: 0x166, script: 0x5b, flags: 0x0},
+	586:  {region: 0xa7, script: 0x4f, flags: 0x0},
+	587:  {region: 0x2a, script: 0x5b, flags: 0x0},
+	588:  {region: 0x166, script: 0x5b, flags: 0x0},
+	589:  {region: 0x166, script: 0x5b, flags: 0x0},
+	590:  {region: 0x166, script: 0x5b, flags: 0x0},
+	591:  {region: 0x166, script: 0x5b, flags: 0x0},
+	592:  {region: 0x166, script: 0x5b, flags: 0x0},
+	593:  {region: 0x9a, script: 0x53, flags: 0x0},
+	594:  {region: 0x8c, script: 0x5b, flags: 0x0},
+	595:  {region: 0x166, script: 0x5b, flags: 0x0},
+	596:  {region: 0xac, script: 0x54, flags: 0x0},
+	597:  {region: 0x107, script: 0x20, flags: 0x0},
+	598:  {region: 0x9a, script: 0x22, flags: 0x0},
+	599:  {region: 0x166, script: 0x5b, flags: 0x0},
+	600:  {region: 0x76, script: 0x5b, flags: 0x0},
+	601:  {region: 0x166, script: 0x5b, flags: 0x0},
+	602:  {region: 0xb5, script: 0x5b, flags: 0x0},
+	603:  {region: 0x166, script: 0x5b, flags: 0x0},
+	604:  {region: 0x166, script: 0x5b, flags: 0x0},
+	605:  {region: 0x166, script: 0x5b, flags: 0x0},
+	606:  {region: 0x166, script: 0x5b, flags: 0x0},
+	607:  {region: 0x166, script: 0x5b, flags: 0x0},
+	608:  {region: 0x166, script: 0x5b, flags: 0x0},
+	609:  {region: 0x166, script: 0x5b, flags: 0x0},
+	610:  {region: 0x166, script: 0x2c, flags: 0x0},
+	611:  {region: 0x166, script: 0x5b, flags: 0x0},
+	612:  {region: 0x107, script: 0x20, flags: 0x0},
+	613:  {region: 0x113, script: 0x5b, flags: 0x0},
+	614:  {region: 0xe8, script: 0x5b, flags: 0x0},
+	615:  {region: 0x107, script: 0x5b, flags: 0x0},
+	616:  {region: 0x166, script: 0x5b, flags: 0x0},
+	617:  {region: 0x9a, script: 0x22, flags: 0x0},
+	618:  {region: 0x9a, script: 0x5, flags: 0x0},
+	619:  {region: 0x130, script: 0x5b, flags: 0x0},
+	620:  {region: 0x166, script: 0x5b, flags: 0x0},
+	621:  {region: 0x52, script: 0x5b, flags: 0x0},
+	622:  {region: 0x61, script: 0x5b, flags: 0x0},
+	623:  {region: 0x166, script: 0x5b, flags: 0x0},
+	624:  {region: 0x166, script: 0x5b, flags: 0x0},
+	625:  {region: 0x166, script: 0x2c, flags: 0x0},
+	626:  {region: 0x166, script: 0x5b, flags: 0x0},
+	627:  {region: 0x166, script: 0x5b, flags: 0x0},
+	628:  {region: 0x19, script: 0x3, flags: 0x1},
+	629:  {region: 0x166, script: 0x5b, flags: 0x0},
+	630:  {region: 0x166, script: 0x5b, flags: 0x0},
+	631:  {region: 0x166, script: 0x5b, flags: 0x0},
+	632:  {region: 0x166, script: 0x5b, flags: 0x0},
+	633:  {region: 0x107, script: 0x20, flags: 0x0},
+	634:  {region: 0x166, script: 0x5b, flags: 0x0},
+	635:  {region: 0x166, script: 0x5b, flags: 0x0},
+	636:  {region: 0x166, script: 0x5b, flags: 0x0},
+	637:  {region: 0x107, script: 0x20, flags: 0x0},
+	638:  {region: 0x166, script: 0x5b, flags: 0x0},
+	639:  {region: 0x96, script: 0x5b, flags: 0x0},
+	640:  {region: 0xe9, script: 0x5, flags: 0x0},
+	641:  {region: 0x7c, script: 0x5b, flags: 0x0},
+	642:  {region: 0x166, script: 0x5b, flags: 0x0},
+	643:  {region: 0x166, script: 0x5b, flags: 0x0},
+	644:  {region: 0x166, script: 0x5b, flags: 0x0},
+	645:  {region: 0x166, script: 0x2c, flags: 0x0},
+	646:  {region: 0x124, script: 0xee, flags: 0x0},
+	647:  {region: 0xe9, script: 0x5, flags: 0x0},
+	648:  {region: 0x166, script: 0x5b, flags: 0x0},
+	649:  {region: 0x166, script: 0x5b, flags: 0x0},
+	650:  {region: 0x1c, script: 0x5, flags: 0x1},
+	651:  {region: 0x166, script: 0x5b, flags: 0x0},
+	652:  {region: 0x166, script: 0x5b, flags: 0x0},
+	653:  {region: 0x166, script: 0x5b, flags: 0x0},
+	654:  {region: 0x139, script: 0x5b, flags: 0x0},
+	655:  {region: 0x88, script: 0x5f, flags: 0x0},
+	656:  {region: 0x98, script: 0x3e, flags: 0x0},
+	657:  {region: 0x130, script: 0x5b, flags: 0x0},
+	658:  {region: 0xe9, script: 0x5, flags: 0x0},
+	659:  {region: 0x132, script: 0x5b, flags: 0x0},
+	660:  {region: 0x166, script: 0x5b, flags: 0x0},
+	661:  {region: 0xb8, script: 0x5b, flags: 0x0},
+	662:  {region: 0x107, script: 0x20, flags: 0x0},
+	663:  {region: 0x166, script: 0x5b, flags: 0x0},
+	664:  {region: 0x96, script: 0x5b, flags: 0x0},
+	665:  {region: 0x166, script: 0x5b, flags: 0x0},
+	666:  {region: 0x53, script: 0xee, flags: 0x0},
+	667:  {region: 0x166, script: 0x5b, flags: 0x0},
+	668:  {region: 0x166, script: 0x5b, flags: 0x0},
+	669:  {region: 0x166, script: 0x5b, flags: 0x0},
+	670:  {region: 0x166, script: 0x5b, flags: 0x0},
+	671:  {region: 0x9a, script: 0x5d, flags: 0x0},
+	672:  {region: 0x166, script: 0x5b, flags: 0x0},
+	673:  {region: 0x166, script: 0x5b, flags: 0x0},
+	674:  {region: 0x107, script: 0x20, flags: 0x0},
+	675:  {region: 0x132, script: 0x5b, flags: 0x0},
+	676:  {region: 0x166, script: 0x5b, flags: 0x0},
+	677:  {region: 0xda, script: 0x5b, flags: 0x0},
+	678:  {region: 0x166, script: 0x5b, flags: 0x0},
+	679:  {region: 0x166, script: 0x5b, flags: 0x0},
+	680:  {region: 0x21, script: 0x2, flags: 0x1},
+	681:  {region: 0x166, script: 0x5b, flags: 0x0},
+	682:  {region: 0x166, script: 0x5b, flags: 0x0},
+	683:  {region: 0x9f, script: 0x5b, flags: 0x0},
+	684:  {region: 0x53, script: 0x61, flags: 0x0},
+	685:  {region: 0x96, script: 0x5b, flags: 0x0},
+	686:  {region: 0x9d, script: 0x5, flags: 0x0},
+	687:  {region: 0x136, script: 0x5b, flags: 0x0},
+	688:  {region: 0x166, script: 0x5b, flags: 0x0},
+	689:  {region: 0x166, script: 0x5b, flags: 0x0},
+	690:  {region: 0x9a, script: 0xe9, flags: 0x0},
+	691:  {region: 0x9f, script: 0x5b, flags: 0x0},
+	692:  {region: 0x166, script: 0x5b, flags: 0x0},
+	693:  {region: 0x4b, script: 0x5b, flags: 0x0},
+	694:  {region: 0x166, script: 0x5b, flags: 0x0},
+	695:  {region: 0x166, script: 0x5b, flags: 0x0},
+	696:  {region: 0xb0, script: 0x58, flags: 0x0},
+	697:  {region: 0x166, script: 0x5b, flags: 0x0},
+	698:  {region: 0x166, script: 0x5b, flags: 0x0},
+	699:  {region: 0x4b, script: 0x5b, flags: 0x0},
+	700:  {region: 0x166, script: 0x5b, flags: 0x0},
+	701:  {region: 0x166, script: 0x5b, flags: 0x0},
+	702:  {region: 0x163, script: 0x5b, flags: 0x0},
+	703:  {region: 0x9d, script: 0x5, flags: 0x0},
+	704:  {region: 0xb7, script: 0x5b, flags: 0x0},
+	705:  {region: 0xb9, script: 0x5b, flags: 0x0},
+	706:  {region: 0x4b, script: 0x5b, flags: 0x0},
+	707:  {region: 0x4b, script: 0x5b, flags: 0x0},
+	708:  {region: 0xa5, script: 0x5b, flags: 0x0},
+	709:  {region: 0xa5, script: 0x5b, flags: 0x0},
+	710:  {region: 0x9d, script: 0x5, flags: 0x0},
+	711:  {region: 0xb9, script: 0x5b, flags: 0x0},
+	712:  {region: 0x124, script: 0xee, flags: 0x0},
+	713:  {region: 0x53, script: 0x3b, flags: 0x0},
+	714:  {region: 0x12c, script: 0x5b, flags: 0x0},
+	715:  {region: 0x96, script: 0x5b, flags: 0x0},
+	716:  {region: 0x52, script: 0x5b, flags: 0x0},
+	717:  {region: 0x9a, script: 0x22, flags: 0x0},
+	718:  {region: 0x9a, script: 0x22, flags: 0x0},
+	719:  {region: 0x96, script: 0x5b, flags: 0x0},
+	720:  {region: 0x23, script: 0x3, flags: 0x1},
+	721:  {region: 0xa5, script: 0x5b, flags: 0x0},
+	722:  {region: 0x166, script: 0x5b, flags: 0x0},
+	723:  {region: 0xd0, script: 0x5b, flags: 0x0},
+	724:  {region: 0x166, script: 0x5b, flags: 0x0},
+	725:  {region: 0x166, script: 0x5b, flags: 0x0},
+	726:  {region: 0x166, script: 0x5b, flags: 0x0},
+	727:  {region: 0x166, script: 0x5b, flags: 0x0},
+	728:  {region: 0x166, script: 0x5b, flags: 0x0},
+	729:  {region: 0x166, script: 0x5b, flags: 0x0},
+	730:  {region: 0x166, script: 0x5b, flags: 0x0},
+	731:  {region: 0x166, script: 0x5b, flags: 0x0},
+	732:  {region: 0x166, script: 0x5b, flags: 0x0},
+	733:  {region: 0x166, script: 0x5b, flags: 0x0},
+	734:  {region: 0x166, script: 0x5b, flags: 0x0},
+	735:  {region: 0x166, script: 0x5, flags: 0x0},
+	736:  {region: 0x107, script: 0x20, flags: 0x0},
+	737:  {region: 0xe8, script: 0x5b, flags: 0x0},
+	738:  {region: 0x166, script: 0x5b, flags: 0x0},
+	739:  {region: 0x96, script: 0x5b, flags: 0x0},
+	740:  {region: 0x166, script: 0x2c, flags: 0x0},
+	741:  {region: 0x166, script: 0x5b, flags: 0x0},
+	742:  {region: 0x166, script: 0x5b, flags: 0x0},
+	743:  {region: 0x166, script: 0x5b, flags: 0x0},
+	744:  {region: 0x113, script: 0x5b, flags: 0x0},
+	745:  {region: 0xa5, script: 0x5b, flags: 0x0},
+	746:  {region: 0x166, script: 0x5b, flags: 0x0},
+	747:  {region: 0x166, script: 0x5b, flags: 0x0},
+	748:  {region: 0x124, script: 0x5, flags: 0x0},
+	749:  {region: 0xcd, script: 0x5b, flags: 0x0},
+	750:  {region: 0x166, script: 0x5b, flags: 0x0},
+	751:  {region: 0x166, script: 0x5b, flags: 0x0},
+	752:  {region: 0x166, script: 0x5b, flags: 0x0},
+	753:  {region: 0xc0, script: 0x5b, flags: 0x0},
+	754:  {region: 0xd2, script: 0x5b, flags: 0x0},
+	755:  {region: 0x166, script: 0x5b, flags: 0x0},
+	756:  {region: 0x52, script: 0x5b, flags: 0x0},
+	757:  {region: 0xdc, script: 0x22, flags: 0x0},
+	758:  {region: 0x130, script: 0x5b, flags: 0x0},
+	759:  {region: 0xc1, script: 0x5b, flags: 0x0},
+	760:  {region: 0x166, script: 0x5b, flags: 0x0},
+	761:  {region: 0x166, script: 0x5b, flags: 0x0},
+	762:  {region: 0xe1, script: 0x5b, flags: 0x0},
+	763:  {region: 0x166, script: 0x5b, flags: 0x0},
+	764:  {region: 0x96, script: 0x5b, flags: 0x0},
+	765:  {region: 0x9c, script: 0x3d, flags: 0x0},
+	766:  {region: 0x166, script: 0x5b, flags: 0x0},
+	767:  {region: 0xc3, script: 0x20, flags: 0x0},
+	768:  {region: 0x166, script: 0x5, flags: 0x0},
+	769:  {region: 0x166, script: 0x5b, flags: 0x0},
+	770:  {region: 0x166, script: 0x5b, flags: 0x0},
+	771:  {region: 0x166, script: 0x5b, flags: 0x0},
+	772:  {region: 0x9a, script: 0x6f, flags: 0x0},
+	773:  {region: 0x166, script: 0x5b, flags: 0x0},
+	774:  {region: 0x166, script: 0x5b, flags: 0x0},
+	775:  {region: 0x10c, script: 0x5b, flags: 0x0},
+	776:  {region: 0x166, script: 0x5b, flags: 0x0},
+	777:  {region: 0x166, script: 0x5b, flags: 0x0},
+	778:  {region: 0x166, script: 0x5b, flags: 0x0},
+	779:  {region: 0x26, script: 0x3, flags: 0x1},
+	780:  {region: 0x166, script: 0x5b, flags: 0x0},
+	781:  {region: 0x166, script: 0x5b, flags: 0x0},
+	782:  {region: 0x9a, script: 0xe, flags: 0x0},
+	783:  {region: 0xc5, script: 0x76, flags: 0x0},
+	785:  {region: 0x166, script: 0x5b, flags: 0x0},
+	786:  {region: 0x49, script: 0x5b, flags: 0x0},
+	787:  {region: 0x49, script: 0x5b, flags: 0x0},
+	788:  {region: 0x37, script: 0x5b, flags: 0x0},
+	789:  {region: 0x166, script: 0x5b, flags: 0x0},
+	790:  {region: 0x166, script: 0x5b, flags: 0x0},
+	791:  {region: 0x166, script: 0x5b, flags: 0x0},
+	792:  {region: 0x166, script: 0x5b, flags: 0x0},
+	793:  {region: 0x166, script: 0x5b, flags: 0x0},
+	794:  {region: 0x166, script: 0x5b, flags: 0x0},
+	795:  {region: 0x9a, script: 0x22, flags: 0x0},
+	796:  {region: 0xdc, script: 0x22, flags: 0x0},
+	797:  {region: 0x107, script: 0x20, flags: 0x0},
+	798:  {region: 0x35, script: 0x73, flags: 0x0},
+	799:  {region: 0x29, script: 0x3, flags: 0x1},
+	800:  {region: 0xcc, script: 0x5b, flags: 0x0},
+	801:  {region: 0x166, script: 0x5b, flags: 0x0},
+	802:  {region: 0x166, script: 0x5b, flags: 0x0},
+	803:  {region: 0x166, script: 0x5b, flags: 0x0},
+	804:  {region: 0x9a, script: 0x22, flags: 0x0},
+	805:  {region: 0x52, script: 0x5b, flags: 0x0},
+	807:  {region: 0x166, script: 0x5b, flags: 0x0},
+	808:  {region: 0x136, script: 0x5b, flags: 0x0},
+	809:  {region: 0x166, script: 0x5b, flags: 0x0},
+	810:  {region: 0x166, script: 0x5b, flags: 0x0},
+	811:  {region: 0xe9, script: 0x5, flags: 0x0},
+	812:  {region: 0xc4, script: 0x5b, flags: 0x0},
+	813:  {region: 0x9a, script: 0x22, flags: 0x0},
+	814:  {region: 0x96, script: 0x5b, flags: 0x0},
+	815:  {region: 0x165, script: 0x5b, flags: 0x0},
+	816:  {region: 0x166, script: 0x5b, flags: 0x0},
+	817:  {region: 0xc5, script: 0x76, flags: 0x0},
+	818:  {region: 0x166, script: 0x5b, flags: 0x0},
+	819:  {region: 0x166, script: 0x2c, flags: 0x0},
+	820:  {region: 0x107, script: 0x20, flags: 0x0},
+	821:  {region: 0x166, script: 0x5b, flags: 0x0},
+	822:  {region: 0x132, script: 0x5b, flags: 0x0},
+	823:  {region: 0x9d, script: 0x67, flags: 0x0},
+	824:  {region: 0x166, script: 0x5b, flags: 0x0},
+	825:  {region: 0x166, script: 0x5b, flags: 0x0},
+	826:  {region: 0x9d, script: 0x5, flags: 0x0},
+	827:  {region: 0x166, script: 0x5b, flags: 0x0},
+	828:  {region: 0x166, script: 0x5b, flags: 0x0},
+	829:  {region: 0x166, script: 0x5b, flags: 0x0},
+	830:  {region: 0xde, script: 0x5b, flags: 0x0},
+	831:  {region: 0x166, script: 0x5b, flags: 0x0},
+	832:  {region: 0x166, script: 0x5b, flags: 0x0},
+	834:  {region: 0x166, script: 0x5b, flags: 0x0},
+	835:  {region: 0x53, script: 0x3b, flags: 0x0},
+	836:  {region: 0x9f, script: 0x5b, flags: 0x0},
+	837:  {region: 0xd3, script: 0x5b, flags: 0x0},
+	838:  {region: 0x166, script: 0x5b, flags: 0x0},
+	839:  {region: 0xdb, script: 0x5b, flags: 0x0},
+	840:  {region: 0x166, script: 0x5b, flags: 0x0},
+	841:  {region: 0x166, script: 0x5b, flags: 0x0},
+	842:  {region: 0x166, script: 0x5b, flags: 0x0},
+	843:  {region: 0xd0, script: 0x5b, flags: 0x0},
+	844:  {region: 0x166, script: 0x5b, flags: 0x0},
+	845:  {region: 0x166, script: 0x5b, flags: 0x0},
+	846:  {region: 0x165, script: 0x5b, flags: 0x0},
+	847:  {region: 0xd2, script: 0x5b, flags: 0x0},
+	848:  {region: 0x61, script: 0x5b, flags: 0x0},
+	849:  {region: 0xdc, script: 0x22, flags: 0x0},
+	850:  {region: 0x166, script: 0x5b, flags: 0x0},
+	851:  {region: 0xdc, script: 0x22, flags: 0x0},
+	852:  {region: 0x166, script: 0x5b, flags: 0x0},
+	853:  {region: 0x166, script: 0x5b, flags: 0x0},
+	854:  {region: 0xd3, script: 0x5b, flags: 0x0},
+	855:  {region: 0x166, script: 0x5b, flags: 0x0},
+	856:  {region: 0x166, script: 0x5b, flags: 0x0},
+	857:  {region: 0xd2, script: 0x5b, flags: 0x0},
+	858:  {region: 0x166, script: 0x5b, flags: 0x0},
+	859:  {region: 0xd0, script: 0x5b, flags: 0x0},
+	860:  {region: 0xd0, script: 0x5b, flags: 0x0},
+	861:  {region: 0x166, script: 0x5b, flags: 0x0},
+	862:  {region: 0x166, script: 0x5b, flags: 0x0},
+	863:  {region: 0x96, script: 0x5b, flags: 0x0},
+	864:  {region: 0x166, script: 0x5b, flags: 0x0},
+	865:  {region: 0xe0, script: 0x5b, flags: 0x0},
+	866:  {region: 0x166, script: 0x5b, flags: 0x0},
+	867:  {region: 0x166, script: 0x5b, flags: 0x0},
+	868:  {region: 0x9a, script: 0x5b, flags: 0x0},
+	869:  {region: 0x166, script: 0x5b, flags: 0x0},
+	870:  {region: 0x166, script: 0x5b, flags: 0x0},
+	871:  {region: 0xda, script: 0x5b, flags: 0x0},
+	872:  {region: 0x52, script: 0x5b, flags: 0x0},
+	873:  {region: 0x166, script: 0x5b, flags: 0x0},
+	874:  {region: 0xdb, script: 0x5b, flags: 0x0},
+	875:  {region: 0x166, script: 0x5b, flags: 0x0},
+	876:  {region: 0x52, script: 0x5b, flags: 0x0},
+	877:  {region: 0x166, script: 0x5b, flags: 0x0},
+	878:  {region: 0x166, script: 0x5b, flags: 0x0},
+	879:  {region: 0xdb, script: 0x5b, flags: 0x0},
+	880:  {region: 0x124, script: 0x57, flags: 0x0},
+	881:  {region: 0x9a, script: 0x22, flags: 0x0},
+	882:  {region: 0x10d, script: 0xcb, flags: 0x0},
+	883:  {region: 0x166, script: 0x5b, flags: 0x0},
+	884:  {region: 0x166, script: 0x5b, flags: 0x0},
+	885:  {region: 0x85, script: 0x7e, flags: 0x0},
+	886:  {region: 0x162, script: 0x5b, flags: 0x0},
+	887:  {region: 0x166, script: 0x5b, flags: 0x0},
+	888:  {region: 0x49, script: 0x17, flags: 0x0},
+	889:  {region: 0x166, script: 0x5b, flags: 0x0},
+	890:  {region: 0x162, script: 0x5b, flags: 0x0},
+	891:  {region: 0x166, script: 0x5b, flags: 0x0},
+	892:  {region: 0x166, script: 0x5b, flags: 0x0},
+	893:  {region: 0x166, script: 0x5b, flags: 0x0},
+	894:  {region: 0x166, script: 0x5b, flags: 0x0},
+	895:  {region: 0x166, script: 0x5b, flags: 0x0},
+	896:  {region: 0x118, script: 0x5b, flags: 0x0},
+	897:  {region: 0x166, script: 0x5b, flags: 0x0},
+	898:  {region: 0x166, script: 0x5b, flags: 0x0},
+	899:  {region: 0x136, script: 0x5b, flags: 0x0},
+	900:  {region: 0x166, script: 0x5b, flags: 0x0},
+	901:  {region: 0x53, script: 0x5b, flags: 0x0},
+	902:  {region: 0x166, script: 0x5b, flags: 0x0},
+	903:  {region: 0xcf, script: 0x5b, flags: 0x0},
+	904:  {region: 0x130, script: 0x5b, flags: 0x0},
+	905:  {region: 0x132, script: 0x5b, flags: 0x0},
+	906:  {region: 0x81, script: 0x5b, flags: 0x0},
+	907:  {region: 0x79, script: 0x5b, flags: 0x0},
+	908:  {region: 0x166, script: 0x5b, flags: 0x0},
+	910:  {region: 0x166, script: 0x5b, flags: 0x0},
+	911:  {region: 0x166, script: 0x5b, flags: 0x0},
+	912:  {region: 0x70, script: 0x5b, flags: 0x0},
+	913:  {region: 0x166, script: 0x5b, flags: 0x0},
+	914:  {region: 0x166, script: 0x5b, flags: 0x0},
+	915:  {region: 0x166, script: 0x5b, flags: 0x0},
+	916:  {region: 0x166, script: 0x5b, flags: 0x0},
+	917:  {region: 0x9a, script: 0x83, flags: 0x0},
+	918:  {region: 0x166, script: 0x5b, flags: 0x0},
+	919:  {region: 0x166, script: 0x5, flags: 0x0},
+	920:  {region: 0x7e, script: 0x20, flags: 0x0},
+	921:  {region: 0x136, script: 0x84, flags: 0x0},
+	922:  {region: 0x166, script: 0x5, flags: 0x0},
+	923:  {region: 0xc6, script: 0x82, flags: 0x0},
+	924:  {region: 0x166, script: 0x5b, flags: 0x0},
+	925:  {region: 0x2c, script: 0x3, flags: 0x1},
+	926:  {region: 0xe8, script: 0x5b, flags: 0x0},
+	927:  {region: 0x2f, script: 0x2, flags: 0x1},
+	928:  {region: 0xe8, script: 0x5b, flags: 0x0},
+	929:  {region: 0x30, script: 0x5b, flags: 0x0},
+	930:  {region: 0xf1, script: 0x5b, flags: 0x0},
+	931:  {region: 0x166, script: 0x5b, flags: 0x0},
+	932:  {region: 0x79, script: 0x5b, flags: 0x0},
+	933:  {region: 0xd7, script: 0x5b, flags: 0x0},
+	934:  {region: 0x136, script: 0x5b, flags: 0x0},
+	935:  {region: 0x49, script: 0x5b, flags: 0x0},
+	936:  {region: 0x166, script: 0x5b, flags: 0x0},
+	937:  {region: 0x9d, script: 0xfa, flags: 0x0},
+	938:  {region: 0x166, script: 0x5b, flags: 0x0},
+	939:  {region: 0x61, script: 0x5b, flags: 0x0},
+	940:  {region: 0x166, script: 0x5, flags: 0x0},
+	941:  {region: 0xb1, script: 0x90, flags: 0x0},
+	943:  {region: 0x166, script: 0x5b, flags: 0x0},
+	944:  {region: 0x166, script: 0x5b, flags: 0x0},
+	945:  {region: 0x9a, script: 0x12, flags: 0x0},
+	946:  {region: 0xa5, script: 0x5b, flags: 0x0},
+	947:  {region: 0xea, script: 0x5b, flags: 0x0},
+	948:  {region: 0x166, script: 0x5b, flags: 0x0},
+	949:  {region: 0x9f, script: 0x5b, flags: 0x0},
+	950:  {region: 0x166, script: 0x5b, flags: 0x0},
+	951:  {region: 0x166, script: 0x5b, flags: 0x0},
+	952:  {region: 0x88, script: 0x34, flags: 0x0},
+	953:  {region: 0x76, script: 0x5b, flags: 0x0},
+	954:  {region: 0x166, script: 0x5b, flags: 0x0},
+	955:  {region: 0xe9, script: 0x4e, flags: 0x0},
+	956:  {region: 0x9d, script: 0x5, flags: 0x0},
+	957:  {region: 0x1, script: 0x5b, flags: 0x0},
+	958:  {region: 0x24, script: 0x5, flags: 0x0},
+	959:  {region: 0x166, script: 0x5b, flags: 0x0},
+	960:  {region: 0x41, script: 0x5b, flags: 0x0},
+	961:  {region: 0x166, script: 0x5b, flags: 0x0},
+	962:  {region: 0x7b, script: 0x5b, flags: 0x0},
+	963:  {region: 0x166, script: 0x5b, flags: 0x0},
+	964:  {region: 0xe5, script: 0x5b, flags: 0x0},
+	965:  {region: 0x8a, script: 0x5b, flags: 0x0},
+	966:  {region: 0x6a, script: 0x5b, flags: 0x0},
+	967:  {region: 0x166, script: 0x5b, flags: 0x0},
+	968:  {region: 0x9a, script: 0x22, flags: 0x0},
+	969:  {region: 0x166, script: 0x5b, flags: 0x0},
+	970:  {region: 0x103, script: 0x5b, flags: 0x0},
+	971:  {region: 0x96, script: 0x5b, flags: 0x0},
+	972:  {region: 0x166, script: 0x5b, flags: 0x0},
+	973:  {region: 0x166, script: 0x5b, flags: 0x0},
+	974:  {region: 0x9f, script: 0x5b, flags: 0x0},
+	975:  {region: 0x166, script: 0x5, flags: 0x0},
+	976:  {region: 0x9a, script: 0x5b, flags: 0x0},
+	977:  {region: 0x31, script: 0x2, flags: 0x1},
+	978:  {region: 0xdc, script: 0x22, flags: 0x0},
+	979:  {region: 0x35, script: 0xe, flags: 0x0},
+	980:  {region: 0x4e, script: 0x5b, flags: 0x0},
+	981:  {region: 0x73, script: 0x5b, flags: 0x0},
+	982:  {region: 0x4e, script: 0x5b, flags: 0x0},
+	983:  {region: 0x9d, script: 0x5, flags: 0x0},
+	984:  {region: 0x10d, script: 0x5b, flags: 0x0},
+	985:  {region: 0x3a, script: 0x5b, flags: 0x0},
+	986:  {region: 0x166, script: 0x5b, flags: 0x0},
+	987:  {region: 0xd2, script: 0x5b, flags: 0x0},
+	988:  {region: 0x105, script: 0x5b, flags: 0x0},
+	989:  {region: 0x96, script: 0x5b, flags: 0x0},
+	990:  {region: 0x130, script: 0x5b, flags: 0x0},
+	991:  {region: 0x166, script: 0x5b, flags: 0x0},
+	992:  {region: 0x166, script: 0x5b, flags: 0x0},
+	993:  {region: 0x74, script: 0x5b, flags: 0x0},
+	994:  {region: 0x107, script: 0x20, flags: 0x0},
+	995:  {region: 0x131, script: 0x20, flags: 0x0},
+	996:  {region: 0x10a, script: 0x5b, flags: 0x0},
+	997:  {region: 0x108, script: 0x5b, flags: 0x0},
+	998:  {region: 0x130, script: 0x5b, flags: 0x0},
+	999:  {region: 0x166, script: 0x5b, flags: 0x0},
+	1000: {region: 0xa3, script: 0x4c, flags: 0x0},
+	1001: {region: 0x9a, script: 0x22, flags: 0x0},
+	1002: {region: 0x81, script: 0x5b, flags: 0x0},
+	1003: {region: 0x107, script: 0x20, flags: 0x0},
+	1004: {region: 0xa5, script: 0x5b, flags: 0x0},
+	1005: {region: 0x96, script: 0x5b, flags: 0x0},
+	1006: {region: 0x9a, script: 0x5b, flags: 0x0},
+	1007: {region: 0x115, script: 0x5b, flags: 0x0},
+	1008: {region: 0x9a, script: 0xcf, flags: 0x0},
+	1009: {region: 0x166, script: 0x5b, flags: 0x0},
+	1010: {region: 0x166, script: 0x5b, flags: 0x0},
+	1011: {region: 0x130, script: 0x5b, flags: 0x0},
+	1012: {region: 0x9f, script: 0x5b, flags: 0x0},
+	1013: {region: 0x9a, script: 0x22, flags: 0x0},
+	1014: {region: 0x166, script: 0x5, flags: 0x0},
+	1015: {region: 0x9f, script: 0x5b, flags: 0x0},
+	1016: {region: 0x7c, script: 0x5b, flags: 0x0},
+	1017: {region: 0x49, script: 0x5b, flags: 0x0},
+	1018: {region: 0x33, script: 0x4, flags: 0x1},
+	1019: {region: 0x9f, script: 0x5b, flags: 0x0},
+	1020: {region: 0x9d, script: 0x5, flags: 0x0},
+	1021: {region: 0xdb, script: 0x5b, flags: 0x0},
+	1022: {region: 0x4f, script: 0x5b, flags: 0x0},
+	1023: {region: 0xd2, script: 0x5b, flags: 0x0},
+	1024: {region: 0xd0, script: 0x5b, flags: 0x0},
+	1025: {region: 0xc4, script: 0x5b, flags: 0x0},
+	1026: {region: 0x4c, script: 0x5b, flags: 0x0},
+	1027: {region: 0x97, script: 0x80, flags: 0x0},
+	1028: {region: 0xb7, script: 0x5b, flags: 0x0},
+	1029: {region: 0x166, script: 0x2c, flags: 0x0},
+	1030: {region: 0x166, script: 0x5b, flags: 0x0},
+	1032: {region: 0xbb, script: 0xeb, flags: 0x0},
+	1033: {region: 0x166, script: 0x5b, flags: 0x0},
+	1034: {region: 0xc5, script: 0x76, flags: 0x0},
+	1035: {region: 0x166, script: 0x5, flags: 0x0},
+	1036: {region: 0xb4, script: 0xd6, flags: 0x0},
+	1037: {region: 0x70, script: 0x5b, flags: 0x0},
+	1038: {region: 0x166, script: 0x5b, flags: 0x0},
+	1039: {region: 0x166, script: 0x5b, flags: 0x0},
+	1040: {region: 0x166, script: 0x5b, flags: 0x0},
+	1041: {region: 0x166, script: 0x5b, flags: 0x0},
+	1042: {region: 0x112, script: 0x5b, flags: 0x0},
+	1043: {region: 0x166, script: 0x5b, flags: 0x0},
+	1044: {region: 0xe9, script: 0x5, flags: 0x0},
+	1045: {region: 0x166, script: 0x5b, flags: 0x0},
+	1046: {region: 0x110, script: 0x5b, flags: 0x0},
+	1047: {region: 0x166, script: 0x5b, flags: 0x0},
+	1048: {region: 0xea, script: 0x5b, flags: 0x0},
+	1049: {region: 0x166, script: 0x5b, flags: 0x0},
+	1050: {region: 0x96, script: 0x5b, flags: 0x0},
+	1051: {region: 0x143, script: 0x5b, flags: 0x0},
+	1052: {region: 0x10d, script: 0x5b, flags: 0x0},
+	1054: {region: 0x10d, script: 0x5b, flags: 0x0},
+	1055: {region: 0x73, script: 0x5b, flags: 0x0},
+	1056: {region: 0x98, script: 0xcc, flags: 0x0},
+	1057: {region: 0x166, script: 0x5b, flags: 0x0},
+	1058: {region: 0x73, script: 0x5b, flags: 0x0},
+	1059: {region: 0x165, script: 0x5b, flags: 0x0},
+	1060: {region: 0x166, script: 0x5b, flags: 0x0},
+	1061: {region: 0xc4, script: 0x5b, flags: 0x0},
+	1062: {region: 0x166, script: 0x5b, flags: 0x0},
+	1063: {region: 0x166, script: 0x5b, flags: 0x0},
+	1064: {region: 0x166, script: 0x5b, flags: 0x0},
+	1065: {region: 0x116, script: 0x5b, flags: 0x0},
+	1066: {region: 0x166, script: 0x5b, flags: 0x0},
+	1067: {region: 0x166, script: 0x5b, flags: 0x0},
+	1068: {region: 0x124, script: 0xee, flags: 0x0},
+	1069: {region: 0x166, script: 0x5b, flags: 0x0},
+	1070: {region: 0x166, script: 0x5b, flags: 0x0},
+	1071: {region: 0x166, script: 0x5b, flags: 0x0},
+	1072: {region: 0x166, script: 0x5b, flags: 0x0},
+	1073: {region: 0x27, script: 0x5b, flags: 0x0},
+	1074: {region: 0x37, script: 0x5, flags: 0x1},
+	1075: {region: 0x9a, script: 0xd9, flags: 0x0},
+	1076: {region: 0x117, script: 0x5b, flags: 0x0},
+	1077: {region: 0x115, script: 0x5b, flags: 0x0},
+	1078: {region: 0x9a, script: 0x22, flags: 0x0},
+	1079: {region: 0x162, script: 0x5b, flags: 0x0},
+	1080: {region: 0x166, script: 0x5b, flags: 0x0},
+	1081: {region: 0x166, script: 0x5b, flags: 0x0},
+	1082: {region: 0x6e, script: 0x5b, flags: 0x0},
+	1083: {region: 0x162, script: 0x5b, flags: 0x0},
+	1084: {region: 0x166, script: 0x5b, flags: 0x0},
+	1085: {region: 0x61, script: 0x5b, flags: 0x0},
+	1086: {region: 0x96, script: 0x5b, flags: 0x0},
+	1087: {region: 0x166, script: 0x5b, flags: 0x0},
+	1088: {region: 0x166, script: 0x5b, flags: 0x0},
+	1089: {region: 0x130, script: 0x5b, flags: 0x0},
+	1090: {region: 0x166, script: 0x5b, flags: 0x0},
+	1091: {region: 0x85, script: 0x5b, flags: 0x0},
+	1092: {region: 0x10d, script: 0x5b, flags: 0x0},
+	1093: {region: 0x130, script: 0x5b, flags: 0x0},
+	1094: {region: 0x160, script: 0x5, flags: 0x0},
+	1095: {region: 0x4b, script: 0x5b, flags: 0x0},
+	1096: {region: 0x61, script: 0x5b, flags: 0x0},
+	1097: {region: 0x166, script: 0x5b, flags: 0x0},
+	1098: {region: 0x9a, script: 0x22, flags: 0x0},
+	1099: {region: 0x96, script: 0x5b, flags: 0x0},
+	1100: {region: 0x166, script: 0x5b, flags: 0x0},
+	1101: {region: 0x35, script: 0xe, flags: 0x0},
+	1102: {region: 0x9c, script: 0xde, flags: 0x0},
+	1103: {region: 0xea, script: 0x5b, flags: 0x0},
+	1104: {region: 0x9a, script: 0xe6, flags: 0x0},
+	1105: {region: 0xdc, script: 0x22, flags: 0x0},
+	1106: {region: 0x166, script: 0x5b, flags: 0x0},
+	1107: {region: 0x166, script: 0x5b, flags: 0x0},
+	1108: {region: 0x166, script: 0x5b, flags: 0x0},
+	1109: {region: 0x166, script: 0x5b, flags: 0x0},
+	1110: {region: 0x166, script: 0x5b, flags: 0x0},
+	1111: {region: 0x166, script: 0x5b, flags: 0x0},
+	1112: {region: 0x166, script: 0x5b, flags: 0x0},
+	1113: {region: 0x166, script: 0x5b, flags: 0x0},
+	1114: {region: 0xe8, script: 0x5b, flags: 0x0},
+	1115: {region: 0x166, script: 0x5b, flags: 0x0},
+	1116: {region: 0x166, script: 0x5b, flags: 0x0},
+	1117: {region: 0x9a, script: 0x53, flags: 0x0},
+	1118: {region: 0x53, script: 0xe4, flags: 0x0},
+	1119: {region: 0xdc, script: 0x22, flags: 0x0},
+	1120: {region: 0xdc, script: 0x22, flags: 0x0},
+	1121: {region: 0x9a, script: 0xe9, flags: 0x0},
+	1122: {region: 0x166, script: 0x5b, flags: 0x0},
+	1123: {region: 0x113, script: 0x5b, flags: 0x0},
+	1124: {region: 0x132, script: 0x5b, flags: 0x0},
+	1125: {region: 0x127, script: 0x5b, flags: 0x0},
+	1126: {region: 0x166, script: 0x5b, flags: 0x0},
+	1127: {region: 0x3c, script: 0x3, flags: 0x1},
+	1128: {region: 0x166, script: 0x5b, flags: 0x0},
+	1129: {region: 0x166, script: 0x5b, flags: 0x0},
+	1130: {region: 0x166, script: 0x5b, flags: 0x0},
+	1131: {region: 0x124, script: 0xee, flags: 0x0},
+	1132: {region: 0xdc, script: 0x22, flags: 0x0},
+	1133: {region: 0xdc, script: 0x22, flags: 0x0},
+	1134: {region: 0xdc, script: 0x22, flags: 0x0},
+	1135: {region: 0x70, script: 0x2c, flags: 0x0},
+	1136: {region: 0x166, script: 0x5b, flags: 0x0},
+	1137: {region: 0x6e, script: 0x2c, flags: 0x0},
+	1138: {region: 0x166, script: 0x5b, flags: 0x0},
+	1139: {region: 0x166, script: 0x5b, flags: 0x0},
+	1140: {region: 0x166, script: 0x5b, flags: 0x0},
+	1141: {region: 0xd7, script: 0x5b, flags: 0x0},
+	1142: {region: 0x128, script: 0x5b, flags: 0x0},
+	1143: {region: 0x126, script: 0x5b, flags: 0x0},
+	1144: {region: 0x32, script: 0x5b, flags: 0x0},
+	1145: {region: 0xdc, script: 0x22, flags: 0x0},
+	1146: {region: 0xe8, script: 0x5b, flags: 0x0},
+	1147: {region: 0x166, script: 0x5b, flags: 0x0},
+	1148: {region: 0x166, script: 0x5b, flags: 0x0},
+	1149: {region: 0x32, script: 0x5b, flags: 0x0},
+	1150: {region: 0xd5, script: 0x5b, flags: 0x0},
+	1151: {region: 0x166, script: 0x5b, flags: 0x0},
+	1152: {region: 0x162, script: 0x5b, flags: 0x0},
+	1153: {region: 0x166, script: 0x5b, flags: 0x0},
+	1154: {region: 0x12a, script: 0x5b, flags: 0x0},
+	1155: {region: 0x166, script: 0x5b, flags: 0x0},
+	1156: {region: 0xcf, script: 0x5b, flags: 0x0},
+	1157: {region: 0x166, script: 0x5b, flags: 0x0},
+	1158: {region: 0xe7, script: 0x5b, flags: 0x0},
+	1159: {region: 0x166, script: 0x5b, flags: 0x0},
+	1160: {region: 0x166, script: 0x5b, flags: 0x0},
+	1161: {region: 0x166, script: 0x5b, flags: 0x0},
+	1162: {region: 0x12c, script: 0x5b, flags: 0x0},
+	1163: {region: 0x12c, script: 0x5b, flags: 0x0},
+	1164: {region: 0x12f, script: 0x5b, flags: 0x0},
+	1165: {region: 0x166, script: 0x5, flags: 0x0},
+	1166: {region: 0x162, script: 0x5b, flags: 0x0},
+	1167: {region: 0x88, script: 0x34, flags: 0x0},
+	1168: {region: 0xdc, script: 0x22, flags: 0x0},
+	1169: {region: 0xe8, script: 0x5b, flags: 0x0},
+	1170: {region: 0x43, script: 0xef, flags: 0x0},
+	1171: {region: 0x166, script: 0x5b, flags: 0x0},
+	1172: {region: 0x107, script: 0x20, flags: 0x0},
+	1173: {region: 0x166, script: 0x5b, flags: 0x0},
+	1174: {region: 0x166, script: 0x5b, flags: 0x0},
+	1175: {region: 0x132, script: 0x5b, flags: 0x0},
+	1176: {region: 0x166, script: 0x5b, flags: 0x0},
+	1177: {region: 0x124, script: 0xee, flags: 0x0},
+	1178: {region: 0x32, script: 0x5b, flags: 0x0},
+	1179: {region: 0x166, script: 0x5b, flags: 0x0},
+	1180: {region: 0x166, script: 0x5b, flags: 0x0},
+	1181: {region: 0xcf, script: 0x5b, flags: 0x0},
+	1182: {region: 0x166, script: 0x5b, flags: 0x0},
+	1183: {region: 0x166, script: 0x5b, flags: 0x0},
+	1184: {region: 0x12e, script: 0x5b, flags: 0x0},
+	1185: {region: 0x166, script: 0x5b, flags: 0x0},
+	1187: {region: 0x166, script: 0x5b, flags: 0x0},
+	1188: {region: 0xd5, script: 0x5b, flags: 0x0},
+	1189: {region: 0x53, script: 0xe7, flags: 0x0},
+	1190: {region: 0xe6, script: 0x5b, flags: 0x0},
+	1191: {region: 0x166, script: 0x5b, flags: 0x0},
+	1192: {region: 0x107, script: 0x20, flags: 0x0},
+	1193: {region: 0xbb, script: 0x5b, flags: 0x0},
+	1194: {region: 0x166, script: 0x5b, flags: 0x0},
+	1195: {region: 0x107, script: 0x20, flags: 0x0},
+	1196: {region: 0x3f, script: 0x4, flags: 0x1},
+	1197: {region: 0x11d, script: 0xf3, flags: 0x0},
+	1198: {region: 0x131, script: 0x20, flags: 0x0},
+	1199: {region: 0x76, script: 0x5b, flags: 0x0},
+	1200: {region: 0x2a, script: 0x5b, flags: 0x0},
+	1202: {region: 0x43, script: 0x3, flags: 0x1},
+	1203: {region: 0x9a, script: 0xe, flags: 0x0},
+	1204: {region: 0xe9, script: 0x5, flags: 0x0},
+	1205: {region: 0x166, script: 0x5b, flags: 0x0},
+	1206: {region: 0x166, script: 0x5b, flags: 0x0},
+	1207: {region: 0x166, script: 0x5b, flags: 0x0},
+	1208: {region: 0x166, script: 0x5b, flags: 0x0},
+	1209: {region: 0x166, script: 0x5b, flags: 0x0},
+	1210: {region: 0x166, script: 0x5b, flags: 0x0},
+	1211: {region: 0x166, script: 0x5b, flags: 0x0},
+	1212: {region: 0x46, script: 0x4, flags: 0x1},
+	1213: {region: 0x166, script: 0x5b, flags: 0x0},
+	1214: {region: 0xb5, script: 0xf4, flags: 0x0},
+	1215: {region: 0x166, script: 0x5b, flags: 0x0},
+	1216: {region: 0x162, script: 0x5b, flags: 0x0},
+	1217: {region: 0x9f, script: 0x5b, flags: 0x0},
+	1218: {region: 0x107, script: 0x5b, flags: 0x0},
+	1219: {region: 0x13f, script: 0x5b, flags: 0x0},
+	1220: {region: 0x11c, script: 0x5b, flags: 0x0},
+	1221: {region: 0x166, script: 0x5b, flags: 0x0},
+	1222: {region: 0x36, script: 0x5b, flags: 0x0},
+	1223: {region: 0x61, script: 0x5b, flags: 0x0},
+	1224: {region: 0xd2, script: 0x5b, flags: 0x0},
+	1225: {region: 0x1, script: 0x5b, flags: 0x0},
+	1226: {region: 0x107, script: 0x5b, flags: 0x0},
+	1227: {region: 0x6b, script: 0x5b, flags: 0x0},
+	1228: {region: 0x130, script: 0x5b, flags: 0x0},
+	1229: {region: 0x166, script: 0x5b, flags: 0x0},
+	1230: {region: 0x36, script: 0x5b, flags: 0x0},
+	1231: {region: 0x4e, script: 0x5b, flags: 0x0},
+	1232: {region: 0x166, script: 0x5b, flags: 0x0},
+	1233: {region: 0x70, script: 0x2c, flags: 0x0},
+	1234: {region: 0x166, script: 0x5b, flags: 0x0},
+	1235: {region: 0xe8, script: 0x5b, flags: 0x0},
+	1236: {region: 0x2f, script: 0x5b, flags: 0x0},
+	1237: {region: 0x9a, script: 0xe9, flags: 0x0},
+	1238: {region: 0x9a, script: 0x22, flags: 0x0},
+	1239: {region: 0x166, script: 0x5b, flags: 0x0},
+	1240: {region: 0x166, script: 0x5b, flags: 0x0},
+	1241: {region: 0x166, script: 0x5b, flags: 0x0},
+	1242: {region: 0x166, script: 0x5b, flags: 0x0},
+	1243: {region: 0x166, script: 0x5b, flags: 0x0},
+	1244: {region: 0x166, script: 0x5b, flags: 0x0},
+	1245: {region: 0x166, script: 0x5b, flags: 0x0},
+	1246: {region: 0x166, script: 0x5b, flags: 0x0},
+	1247: {region: 0x166, script: 0x5b, flags: 0x0},
+	1248: {region: 0x141, script: 0x5b, flags: 0x0},
+	1249: {region: 0x166, script: 0x5b, flags: 0x0},
+	1250: {region: 0x166, script: 0x5b, flags: 0x0},
+	1251: {region: 0xa9, script: 0x5, flags: 0x0},
+	1252: {region: 0x166, script: 0x5b, flags: 0x0},
+	1253: {region: 0x115, script: 0x5b, flags: 0x0},
+	1254: {region: 0x166, script: 0x5b, flags: 0x0},
+	1255: {region: 0x166, script: 0x5b, flags: 0x0},
+	1256: {region: 0x166, script: 0x5b, flags: 0x0},
+	1257: {region: 0x166, script: 0x5b, flags: 0x0},
+	1258: {region: 0x9a, script: 0x22, flags: 0x0},
+	1259: {region: 0x53, script: 0x3b, flags: 0x0},
+	1260: {region: 0x166, script: 0x5b, flags: 0x0},
+	1261: {region: 0x166, script: 0x5b, flags: 0x0},
+	1262: {region: 0x41, script: 0x5b, flags: 0x0},
+	1263: {region: 0x166, script: 0x5b, flags: 0x0},
+	1264: {region: 0x12c, script: 0x18, flags: 0x0},
+	1265: {region: 0x166, script: 0x5b, flags: 0x0},
+	1266: {region: 0x162, script: 0x5b, flags: 0x0},
+	1267: {region: 0x166, script: 0x5b, flags: 0x0},
+	1268: {region: 0x12c, script: 0x63, flags: 0x0},
+	1269: {region: 0x12c, script: 0x64, flags: 0x0},
+	1270: {region: 0x7e, script: 0x2e, flags: 0x0},
+	1271: {region: 0x53, script: 0x68, flags: 0x0},
+	1272: {region: 0x10c, script: 0x6d, flags: 0x0},
+	1273: {region: 0x109, script: 0x79, flags: 0x0},
+	1274: {region: 0x9a, script: 0x22, flags: 0x0},
+	1275: {region: 0x132, script: 0x5b, flags: 0x0},
+	1276: {region: 0x166, script: 0x5b, flags: 0x0},
+	1277: {region: 0x9d, script: 0x93, flags: 0x0},
+	1278: {region: 0x166, script: 0x5b, flags: 0x0},
+	1279: {region: 0x15f, script: 0xce, flags: 0x0},
+	1280: {region: 0x166, script: 0x5b, flags: 0x0},
+	1281: {region: 0x166, script: 0x5b, flags: 0x0},
+	1282: {region: 0xdc, script: 0x22, flags: 0x0},
+	1283: {region: 0x166, script: 0x5b, flags: 0x0},
+	1284: {region: 0x166, script: 0x5b, flags: 0x0},
+	1285: {region: 0xd2, script: 0x5b, flags: 0x0},
+	1286: {region: 0x76, script: 0x5b, flags: 0x0},
+	1287: {region: 0x166, script: 0x5b, flags: 0x0},
+	1288: {region: 0x166, script: 0x5b, flags: 0x0},
+	1289: {region: 0x52, script: 0x5b, flags: 0x0},
+	1290: {region: 0x166, script: 0x5b, flags: 0x0},
+	1291: {region: 0x166, script: 0x5b, flags: 0x0},
+	1292: {region: 0x166, script: 0x5b, flags: 0x0},
+	1293: {region: 0x52, script: 0x5b, flags: 0x0},
+	1294: {region: 0x166, script: 0x5b, flags: 0x0},
+	1295: {region: 0x166, script: 0x5b, flags: 0x0},
+	1296: {region: 0x166, script: 0x5b, flags: 0x0},
+	1297: {region: 0x166, script: 0x5b, flags: 0x0},
+	1298: {region: 0x1, script: 0x3e, flags: 0x0},
+	1299: {region: 0x166, script: 0x5b, flags: 0x0},
+	1300: {region: 0x166, script: 0x5b, flags: 0x0},
+	1301: {region: 0x166, script: 0x5b, flags: 0x0},
+	1302: {region: 0x166, script: 0x5b, flags: 0x0},
+	1303: {region: 0x166, script: 0x5b, flags: 0x0},
+	1304: {region: 0xd7, script: 0x5b, flags: 0x0},
+	1305: {region: 0x166, script: 0x5b, flags: 0x0},
+	1306: {region: 0x166, script: 0x5b, flags: 0x0},
+	1307: {region: 0x166, script: 0x5b, flags: 0x0},
+	1308: {region: 0x41, script: 0x5b, flags: 0x0},
+	1309: {region: 0x166, script: 0x5b, flags: 0x0},
+	1310: {region: 0xd0, script: 0x5b, flags: 0x0},
+	1311: {region: 0x4a, script: 0x3, flags: 0x1},
+	1312: {region: 0x166, script: 0x5b, flags: 0x0},
+	1313: {region: 0x166, script: 0x5b, flags: 0x0},
+	1314: {region: 0x166, script: 0x5b, flags: 0x0},
+	1315: {region: 0x53, script: 0x5b, flags: 0x0},
+	1316: {region: 0x10c, script: 0x5b, flags: 0x0},
+	1318: {region: 0xa9, script: 0x5, flags: 0x0},
+	1319: {region: 0xda, script: 0x5b, flags: 0x0},
+	1320: {region: 0xbb, script: 0xeb, flags: 0x0},
+	1321: {region: 0x4d, script: 0x14, flags: 0x1},
+	1322: {region: 0x53, script: 0x7f, flags: 0x0},
+	1323: {region: 0x166, script: 0x5b, flags: 0x0},
+	1324: {region: 0x123, script: 0x5b, flags: 0x0},
+	1325: {region: 0xd1, script: 0x5b, flags: 0x0},
+	1326: {region: 0x166, script: 0x5b, flags: 0x0},
+	1327: {region: 0x162, script: 0x5b, flags: 0x0},
+	1329: {region: 0x12c, script: 0x5b, flags: 0x0},
+}
+
+// likelyLangList holds lists info associated with likelyLang.
+// Size: 582 bytes, 97 elements
+var likelyLangList = [97]likelyScriptRegion{
+	0:  {region: 0x9d, script: 0x7, flags: 0x0},
+	1:  {region: 0xa2, script: 0x7a, flags: 0x2},
+	2:  {region: 0x11d, script: 0x87, flags: 0x2},
+	3:  {region: 0x32, script: 0x5b, flags: 0x0},
+	4:  {region: 0x9c, script: 0x5, flags: 0x4},
+	5:  {region: 0x9d, script: 0x5, flags: 0x4},
+	6:  {region: 0x107, script: 0x20, flags: 0x4},
+	7:  {region: 0x9d, script: 0x5, flags: 0x2},
+	8:  {region: 0x107, script: 0x20, flags: 0x0},
+	9:  {region: 0x38, script: 0x2f, flags: 0x2},
+	10: {region: 0x136, script: 0x5b, flags: 0x0},
+	11: {region: 0x7c, script: 0xd1, flags: 0x2},
+	12: {region: 0x115, script: 0x5b, flags: 0x0},
+	13: {region: 0x85, script: 0x1, flags: 0x2},
+	14: {region: 0x5e, script: 0x1f, flags: 0x0},
+	15: {region: 0x88, script: 0x60, flags: 0x2},
+	16: {region: 0xd7, script: 0x5b, flags: 0x0},
+	17: {region: 0x52, script: 0x5, flags: 0x4},
+	18: {region: 0x10c, script: 0x5, flags: 0x4},
+	19: {region: 0xaf, script: 0x20, flags: 0x0},
+	20: {region: 0x24, script: 0x5, flags: 0x4},
+	21: {region: 0x53, script: 0x5, flags: 0x4},
+	22: {region: 0x9d, script: 0x5, flags: 0x4},
+	23: {region: 0xc6, script: 0x5, flags: 0x4},
+	24: {region: 0x53, script: 0x5, flags: 0x2},
+	25: {region: 0x12c, script: 0x5b, flags: 0x0},
+	26: {region: 0xb1, script: 0x5, flags: 0x4},
+	27: {region: 0x9c, script: 0x5, flags: 0x2},
+	28: {region: 0xa6, script: 0x20, flags: 0x0},
+	29: {region: 0x53, script: 0x5, flags: 0x4},
+	30: {region: 0x12c, script: 0x5b, flags: 0x4},
+	31: {region: 0x53, script: 0x5, flags: 0x2},
+	32: {region: 0x12c, script: 0x5b, flags: 0x2},
+	33: {region: 0xdc, script: 0x22, flags: 0x0},
+	34: {region: 0x9a, script: 0x5e, flags: 0x2},
+	35: {region: 0x84, script: 0x5b, flags: 0x0},
+	36: {region: 0x85, script: 0x7e, flags: 0x4},
+	37: {region: 0x85, script: 0x7e, flags: 0x2},
+	38: {region: 0xc6, script: 0x20, flags: 0x0},
+	39: {region: 0x53, script: 0x71, flags: 0x4},
+	40: {region: 0x53, script: 0x71, flags: 0x2},
+	41: {region: 0xd1, script: 0x5b, flags: 0x0},
+	42: {region: 0x4a, script: 0x5, flags: 0x4},
+	43: {region: 0x96, script: 0x5, flags: 0x4},
+	44: {region: 0x9a, script: 0x36, flags: 0x0},
+	45: {region: 0xe9, script: 0x5, flags: 0x4},
+	46: {region: 0xe9, script: 0x5, flags: 0x2},
+	47: {region: 0x9d, script: 0x8d, flags: 0x0},
+	48: {region: 0x53, script: 0x8e, flags: 0x2},
+	49: {region: 0xbb, script: 0xeb, flags: 0x0},
+	50: {region: 0xda, script: 0x5b, flags: 0x4},
+	51: {region: 0xe9, script: 0x5, flags: 0x0},
+	52: {region: 0x9a, script: 0x22, flags: 0x2},
+	53: {region: 0x9a, script: 0x50, flags: 0x2},
+	54: {region: 0x9a, script: 0xd5, flags: 0x2},
+	55: {region: 0x106, script: 0x20, flags: 0x0},
+	56: {region: 0xbe, script: 0x5b, flags: 0x4},
+	57: {region: 0x105, script: 0x5b, flags: 0x4},
+	58: {region: 0x107, script: 0x5b, flags: 0x4},
+	59: {region: 0x12c, script: 0x5b, flags: 0x4},
+	60: {region: 0x125, script: 0x20, flags: 0x0},
+	61: {region: 0xe9, script: 0x5, flags: 0x4},
+	62: {region: 0xe9, script: 0x5, flags: 0x2},
+	63: {region: 0x53, script: 0x5, flags: 0x0},
+	64: {region: 0xaf, script: 0x20, flags: 0x4},
+	65: {region: 0xc6, script: 0x20, flags: 0x4},
+	66: {region: 0xaf, script: 0x20, flags: 0x2},
+	67: {region: 0x9a, script: 0xe, flags: 0x0},
+	68: {region: 0xdc, script: 0x22, flags: 0x4},
+	69: {region: 0xdc, script: 0x22, flags: 0x2},
+	70: {region: 0x138, script: 0x5b, flags: 0x0},
+	71: {region: 0x24, script: 0x5, flags: 0x4},
+	72: {region: 0x53, script: 0x20, flags: 0x4},
+	73: {region: 0x24, script: 0x5, flags: 0x2},
+	74: {region: 0x8e, script: 0x3c, flags: 0x0},
+	75: {region: 0x53, script: 0x3b, flags: 0x4},
+	76: {region: 0x53, script: 0x3b, flags: 0x2},
+	77: {region: 0x53, script: 0x3b, flags: 0x0},
+	78: {region: 0x2f, script: 0x3c, flags: 0x4},
+	79: {region: 0x3e, script: 0x3c, flags: 0x4},
+	80: {region: 0x7c, script: 0x3c, flags: 0x4},
+	81: {region: 0x7f, script: 0x3c, flags: 0x4},
+	82: {region: 0x8e, script: 0x3c, flags: 0x4},
+	83: {region: 0x96, script: 0x3c, flags: 0x4},
+	84: {region: 0xc7, script: 0x3c, flags: 0x4},
+	85: {region: 0xd1, script: 0x3c, flags: 0x4},
+	86: {region: 0xe3, script: 0x3c, flags: 0x4},
+	87: {region: 0xe6, script: 0x3c, flags: 0x4},
+	88: {region: 0xe8, script: 0x3c, flags: 0x4},
+	89: {region: 0x117, script: 0x3c, flags: 0x4},
+	90: {region: 0x124, script: 0x3c, flags: 0x4},
+	91: {region: 0x12f, script: 0x3c, flags: 0x4},
+	92: {region: 0x136, script: 0x3c, flags: 0x4},
+	93: {region: 0x13f, script: 0x3c, flags: 0x4},
+	94: {region: 0x12f, script: 0x11, flags: 0x2},
+	95: {region: 0x12f, script: 0x37, flags: 0x2},
+	96: {region: 0x12f, script: 0x3c, flags: 0x2},
+}
+
+type likelyLangScript struct {
+	lang   uint16
+	script uint16
+	flags  uint8
+}
+
+// likelyRegion is a lookup table, indexed by regionID, for the most likely
+// languages and scripts given incomplete information. If more entries exist
+// for a given regionID, lang and script are the index and size respectively
+// of the list in likelyRegionList.
+// TODO: exclude containers and user-definable regions from the list.
+// Size: 2154 bytes, 359 elements
+var likelyRegion = [359]likelyLangScript{
+	34:  {lang: 0xd7, script: 0x5b, flags: 0x0},
+	35:  {lang: 0x3a, script: 0x5, flags: 0x0},
+	36:  {lang: 0x0, script: 0x2, flags: 0x1},
+	39:  {lang: 0x2, script: 0x2, flags: 0x1},
+	40:  {lang: 0x4, script: 0x2, flags: 0x1},
+	42:  {lang: 0x3c0, script: 0x5b, flags: 0x0},
+	43:  {lang: 0x0, script: 0x5b, flags: 0x0},
+	44:  {lang: 0x13e, script: 0x5b, flags: 0x0},
+	45:  {lang: 0x41b, script: 0x5b, flags: 0x0},
+	46:  {lang: 0x10d, script: 0x5b, flags: 0x0},
+	48:  {lang: 0x367, script: 0x5b, flags: 0x0},
+	49:  {lang: 0x444, script: 0x5b, flags: 0x0},
+	50:  {lang: 0x58, script: 0x5b, flags: 0x0},
+	51:  {lang: 0x6, script: 0x2, flags: 0x1},
+	53:  {lang: 0xa5, script: 0xe, flags: 0x0},
+	54:  {lang: 0x367, script: 0x5b, flags: 0x0},
+	55:  {lang: 0x15e, script: 0x5b, flags: 0x0},
+	56:  {lang: 0x7e, script: 0x20, flags: 0x0},
+	57:  {lang: 0x3a, script: 0x5, flags: 0x0},
+	58:  {lang: 0x3d9, script: 0x5b, flags: 0x0},
+	59:  {lang: 0x15e, script: 0x5b, flags: 0x0},
+	60:  {lang: 0x15e, script: 0x5b, flags: 0x0},
+	62:  {lang: 0x31f, script: 0x5b, flags: 0x0},
+	63:  {lang: 0x13e, script: 0x5b, flags: 0x0},
+	64:  {lang: 0x3a1, script: 0x5b, flags: 0x0},
+	65:  {lang: 0x3c0, script: 0x5b, flags: 0x0},
+	67:  {lang: 0x8, script: 0x2, flags: 0x1},
+	69:  {lang: 0x0, script: 0x5b, flags: 0x0},
+	71:  {lang: 0x71, script: 0x20, flags: 0x0},
+	73:  {lang: 0x512, script: 0x3e, flags: 0x2},
+	74:  {lang: 0x31f, script: 0x5, flags: 0x2},
+	75:  {lang: 0x445, script: 0x5b, flags: 0x0},
+	76:  {lang: 0x15e, script: 0x5b, flags: 0x0},
+	77:  {lang: 0x15e, script: 0x5b, flags: 0x0},
+	78:  {lang: 0x10d, script: 0x5b, flags: 0x0},
+	79:  {lang: 0x15e, script: 0x5b, flags: 0x0},
+	81:  {lang: 0x13e, script: 0x5b, flags: 0x0},
+	82:  {lang: 0x15e, script: 0x5b, flags: 0x0},
+	83:  {lang: 0xa, script: 0x4, flags: 0x1},
+	84:  {lang: 0x13e, script: 0x5b, flags: 0x0},
+	85:  {lang: 0x0, script: 0x5b, flags: 0x0},
+	87:  {lang: 0x13e, script: 0x5b, flags: 0x0},
+	90:  {lang: 0x13e, script: 0x5b, flags: 0x0},
+	91:  {lang: 0x3c0, script: 0x5b, flags: 0x0},
+	92:  {lang: 0x3a1, script: 0x5b, flags: 0x0},
+	94:  {lang: 0xe, script: 0x2, flags: 0x1},
+	95:  {lang: 0xfa, script: 0x5b, flags: 0x0},
+	97:  {lang: 0x10d, script: 0x5b, flags: 0x0},
+	99:  {lang: 0x1, script: 0x5b, flags: 0x0},
+	100: {lang: 0x101, script: 0x5b, flags: 0x0},
+	102: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	104: {lang: 0x10, script: 0x2, flags: 0x1},
+	105: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	106: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	107: {lang: 0x140, script: 0x5b, flags: 0x0},
+	108: {lang: 0x3a, script: 0x5, flags: 0x0},
+	109: {lang: 0x3a, script: 0x5, flags: 0x0},
+	110: {lang: 0x46f, script: 0x2c, flags: 0x0},
+	111: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	112: {lang: 0x12, script: 0x2, flags: 0x1},
+	114: {lang: 0x10d, script: 0x5b, flags: 0x0},
+	115: {lang: 0x151, script: 0x5b, flags: 0x0},
+	116: {lang: 0x1c0, script: 0x22, flags: 0x2},
+	119: {lang: 0x158, script: 0x5b, flags: 0x0},
+	121: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	123: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	124: {lang: 0x14, script: 0x2, flags: 0x1},
+	126: {lang: 0x16, script: 0x3, flags: 0x1},
+	127: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	129: {lang: 0x21, script: 0x5b, flags: 0x0},
+	131: {lang: 0x245, script: 0x5b, flags: 0x0},
+	133: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	134: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	135: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	136: {lang: 0x19, script: 0x2, flags: 0x1},
+	137: {lang: 0x0, script: 0x5b, flags: 0x0},
+	138: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	140: {lang: 0x3c0, script: 0x5b, flags: 0x0},
+	142: {lang: 0x529, script: 0x3c, flags: 0x0},
+	143: {lang: 0x0, script: 0x5b, flags: 0x0},
+	144: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	145: {lang: 0x1d1, script: 0x5b, flags: 0x0},
+	146: {lang: 0x1d4, script: 0x5b, flags: 0x0},
+	147: {lang: 0x1d5, script: 0x5b, flags: 0x0},
+	149: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	150: {lang: 0x1b, script: 0x2, flags: 0x1},
+	152: {lang: 0x1bc, script: 0x3e, flags: 0x0},
+	154: {lang: 0x1d, script: 0x3, flags: 0x1},
+	156: {lang: 0x3a, script: 0x5, flags: 0x0},
+	157: {lang: 0x20, script: 0x2, flags: 0x1},
+	158: {lang: 0x1f8, script: 0x5b, flags: 0x0},
+	159: {lang: 0x1f9, script: 0x5b, flags: 0x0},
+	162: {lang: 0x3a, script: 0x5, flags: 0x0},
+	163: {lang: 0x200, script: 0x49, flags: 0x0},
+	165: {lang: 0x445, script: 0x5b, flags: 0x0},
+	166: {lang: 0x28a, script: 0x20, flags: 0x0},
+	167: {lang: 0x22, script: 0x3, flags: 0x1},
+	169: {lang: 0x25, script: 0x2, flags: 0x1},
+	171: {lang: 0x254, script: 0x54, flags: 0x0},
+	172: {lang: 0x254, script: 0x54, flags: 0x0},
+	173: {lang: 0x3a, script: 0x5, flags: 0x0},
+	175: {lang: 0x3e2, script: 0x20, flags: 0x0},
+	176: {lang: 0x27, script: 0x2, flags: 0x1},
+	177: {lang: 0x3a, script: 0x5, flags: 0x0},
+	179: {lang: 0x10d, script: 0x5b, flags: 0x0},
+	180: {lang: 0x40c, script: 0xd6, flags: 0x0},
+	182: {lang: 0x43b, script: 0x5b, flags: 0x0},
+	183: {lang: 0x2c0, script: 0x5b, flags: 0x0},
+	184: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	185: {lang: 0x2c7, script: 0x5b, flags: 0x0},
+	186: {lang: 0x3a, script: 0x5, flags: 0x0},
+	187: {lang: 0x29, script: 0x2, flags: 0x1},
+	188: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	189: {lang: 0x2b, script: 0x2, flags: 0x1},
+	190: {lang: 0x432, script: 0x5b, flags: 0x0},
+	191: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	192: {lang: 0x2f1, script: 0x5b, flags: 0x0},
+	195: {lang: 0x2d, script: 0x2, flags: 0x1},
+	196: {lang: 0xa0, script: 0x5b, flags: 0x0},
+	197: {lang: 0x2f, script: 0x2, flags: 0x1},
+	198: {lang: 0x31, script: 0x2, flags: 0x1},
+	199: {lang: 0x33, script: 0x2, flags: 0x1},
+	201: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	202: {lang: 0x35, script: 0x2, flags: 0x1},
+	204: {lang: 0x320, script: 0x5b, flags: 0x0},
+	205: {lang: 0x37, script: 0x3, flags: 0x1},
+	206: {lang: 0x128, script: 0xed, flags: 0x0},
+	208: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	209: {lang: 0x31f, script: 0x5b, flags: 0x0},
+	210: {lang: 0x3c0, script: 0x5b, flags: 0x0},
+	211: {lang: 0x16, script: 0x5b, flags: 0x0},
+	212: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	213: {lang: 0x1b4, script: 0x5b, flags: 0x0},
+	215: {lang: 0x1b4, script: 0x5, flags: 0x2},
+	217: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	218: {lang: 0x367, script: 0x5b, flags: 0x0},
+	219: {lang: 0x347, script: 0x5b, flags: 0x0},
+	220: {lang: 0x351, script: 0x22, flags: 0x0},
+	226: {lang: 0x3a, script: 0x5, flags: 0x0},
+	227: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	229: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	230: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	231: {lang: 0x486, script: 0x5b, flags: 0x0},
+	232: {lang: 0x153, script: 0x5b, flags: 0x0},
+	233: {lang: 0x3a, script: 0x3, flags: 0x1},
+	234: {lang: 0x3b3, script: 0x5b, flags: 0x0},
+	235: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	237: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	238: {lang: 0x3a, script: 0x5, flags: 0x0},
+	239: {lang: 0x3c0, script: 0x5b, flags: 0x0},
+	241: {lang: 0x3a2, script: 0x5b, flags: 0x0},
+	242: {lang: 0x194, script: 0x5b, flags: 0x0},
+	244: {lang: 0x3a, script: 0x5, flags: 0x0},
+	259: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	261: {lang: 0x3d, script: 0x2, flags: 0x1},
+	262: {lang: 0x432, script: 0x20, flags: 0x0},
+	263: {lang: 0x3f, script: 0x2, flags: 0x1},
+	264: {lang: 0x3e5, script: 0x5b, flags: 0x0},
+	265: {lang: 0x3a, script: 0x5, flags: 0x0},
+	267: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	268: {lang: 0x3a, script: 0x5, flags: 0x0},
+	269: {lang: 0x41, script: 0x2, flags: 0x1},
+	272: {lang: 0x416, script: 0x5b, flags: 0x0},
+	273: {lang: 0x347, script: 0x5b, flags: 0x0},
+	274: {lang: 0x43, script: 0x2, flags: 0x1},
+	276: {lang: 0x1f9, script: 0x5b, flags: 0x0},
+	277: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	278: {lang: 0x429, script: 0x5b, flags: 0x0},
+	279: {lang: 0x367, script: 0x5b, flags: 0x0},
+	281: {lang: 0x3c0, script: 0x5b, flags: 0x0},
+	283: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	285: {lang: 0x45, script: 0x2, flags: 0x1},
+	289: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	290: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	291: {lang: 0x47, script: 0x2, flags: 0x1},
+	292: {lang: 0x49, script: 0x3, flags: 0x1},
+	293: {lang: 0x4c, script: 0x2, flags: 0x1},
+	294: {lang: 0x477, script: 0x5b, flags: 0x0},
+	295: {lang: 0x3c0, script: 0x5b, flags: 0x0},
+	296: {lang: 0x476, script: 0x5b, flags: 0x0},
+	297: {lang: 0x4e, script: 0x2, flags: 0x1},
+	298: {lang: 0x482, script: 0x5b, flags: 0x0},
+	300: {lang: 0x50, script: 0x4, flags: 0x1},
+	302: {lang: 0x4a0, script: 0x5b, flags: 0x0},
+	303: {lang: 0x54, script: 0x2, flags: 0x1},
+	304: {lang: 0x445, script: 0x5b, flags: 0x0},
+	305: {lang: 0x56, script: 0x3, flags: 0x1},
+	306: {lang: 0x445, script: 0x5b, flags: 0x0},
+	310: {lang: 0x512, script: 0x3e, flags: 0x2},
+	311: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	312: {lang: 0x4bc, script: 0x5b, flags: 0x0},
+	313: {lang: 0x1f9, script: 0x5b, flags: 0x0},
+	316: {lang: 0x13e, script: 0x5b, flags: 0x0},
+	319: {lang: 0x4c3, script: 0x5b, flags: 0x0},
+	320: {lang: 0x8a, script: 0x5b, flags: 0x0},
+	321: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	323: {lang: 0x41b, script: 0x5b, flags: 0x0},
+	334: {lang: 0x59, script: 0x2, flags: 0x1},
+	351: {lang: 0x3a, script: 0x5, flags: 0x0},
+	352: {lang: 0x5b, script: 0x2, flags: 0x1},
+	357: {lang: 0x423, script: 0x5b, flags: 0x0},
+}
+
+// likelyRegionList holds lists info associated with likelyRegion.
+// Size: 558 bytes, 93 elements
+var likelyRegionList = [93]likelyLangScript{
+	0:  {lang: 0x148, script: 0x5, flags: 0x0},
+	1:  {lang: 0x476, script: 0x5b, flags: 0x0},
+	2:  {lang: 0x431, script: 0x5b, flags: 0x0},
+	3:  {lang: 0x2ff, script: 0x20, flags: 0x0},
+	4:  {lang: 0x1d7, script: 0x8, flags: 0x0},
+	5:  {lang: 0x274, script: 0x5b, flags: 0x0},
+	6:  {lang: 0xb7, script: 0x5b, flags: 0x0},
+	7:  {lang: 0x432, script: 0x20, flags: 0x0},
+	8:  {lang: 0x12d, script: 0xef, flags: 0x0},
+	9:  {lang: 0x351, script: 0x22, flags: 0x0},
+	10: {lang: 0x529, script: 0x3b, flags: 0x0},
+	11: {lang: 0x4ac, script: 0x5, flags: 0x0},
+	12: {lang: 0x523, script: 0x5b, flags: 0x0},
+	13: {lang: 0x29a, script: 0xee, flags: 0x0},
+	14: {lang: 0x136, script: 0x34, flags: 0x0},
+	15: {lang: 0x48a, script: 0x5b, flags: 0x0},
+	16: {lang: 0x3a, script: 0x5, flags: 0x0},
+	17: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	18: {lang: 0x27, script: 0x2c, flags: 0x0},
+	19: {lang: 0x139, script: 0x5b, flags: 0x0},
+	20: {lang: 0x26a, script: 0x5, flags: 0x2},
+	21: {lang: 0x512, script: 0x3e, flags: 0x2},
+	22: {lang: 0x210, script: 0x2e, flags: 0x0},
+	23: {lang: 0x5, script: 0x20, flags: 0x0},
+	24: {lang: 0x274, script: 0x5b, flags: 0x0},
+	25: {lang: 0x136, script: 0x34, flags: 0x0},
+	26: {lang: 0x2ff, script: 0x20, flags: 0x0},
+	27: {lang: 0x1e1, script: 0x5b, flags: 0x0},
+	28: {lang: 0x31f, script: 0x5, flags: 0x0},
+	29: {lang: 0x1be, script: 0x22, flags: 0x0},
+	30: {lang: 0x4b4, script: 0x5, flags: 0x0},
+	31: {lang: 0x236, script: 0x76, flags: 0x0},
+	32: {lang: 0x148, script: 0x5, flags: 0x0},
+	33: {lang: 0x476, script: 0x5b, flags: 0x0},
+	34: {lang: 0x24a, script: 0x4f, flags: 0x0},
+	35: {lang: 0xe6, script: 0x5, flags: 0x0},
+	36: {lang: 0x226, script: 0xee, flags: 0x0},
+	37: {lang: 0x3a, script: 0x5, flags: 0x0},
+	38: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	39: {lang: 0x2b8, script: 0x58, flags: 0x0},
+	40: {lang: 0x226, script: 0xee, flags: 0x0},
+	41: {lang: 0x3a, script: 0x5, flags: 0x0},
+	42: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	43: {lang: 0x3dc, script: 0x5b, flags: 0x0},
+	44: {lang: 0x4ae, script: 0x20, flags: 0x0},
+	45: {lang: 0x2ff, script: 0x20, flags: 0x0},
+	46: {lang: 0x431, script: 0x5b, flags: 0x0},
+	47: {lang: 0x331, script: 0x76, flags: 0x0},
+	48: {lang: 0x213, script: 0x5b, flags: 0x0},
+	49: {lang: 0x30b, script: 0x20, flags: 0x0},
+	50: {lang: 0x242, script: 0x5, flags: 0x0},
+	51: {lang: 0x529, script: 0x3c, flags: 0x0},
+	52: {lang: 0x3c0, script: 0x5b, flags: 0x0},
+	53: {lang: 0x3a, script: 0x5, flags: 0x0},
+	54: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	55: {lang: 0x2ed, script: 0x5b, flags: 0x0},
+	56: {lang: 0x4b4, script: 0x5, flags: 0x0},
+	57: {lang: 0x88, script: 0x22, flags: 0x0},
+	58: {lang: 0x4b4, script: 0x5, flags: 0x0},
+	59: {lang: 0x4b4, script: 0x5, flags: 0x0},
+	60: {lang: 0xbe, script: 0x22, flags: 0x0},
+	61: {lang: 0x3dc, script: 0x5b, flags: 0x0},
+	62: {lang: 0x7e, script: 0x20, flags: 0x0},
+	63: {lang: 0x3e2, script: 0x20, flags: 0x0},
+	64: {lang: 0x267, script: 0x5b, flags: 0x0},
+	65: {lang: 0x444, script: 0x5b, flags: 0x0},
+	66: {lang: 0x512, script: 0x3e, flags: 0x0},
+	67: {lang: 0x412, script: 0x5b, flags: 0x0},
+	68: {lang: 0x4ae, script: 0x20, flags: 0x0},
+	69: {lang: 0x3a, script: 0x5, flags: 0x0},
+	70: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	71: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	72: {lang: 0x35, script: 0x5, flags: 0x0},
+	73: {lang: 0x46b, script: 0xee, flags: 0x0},
+	74: {lang: 0x2ec, script: 0x5, flags: 0x0},
+	75: {lang: 0x30f, script: 0x76, flags: 0x0},
+	76: {lang: 0x467, script: 0x20, flags: 0x0},
+	77: {lang: 0x148, script: 0x5, flags: 0x0},
+	78: {lang: 0x3a, script: 0x5, flags: 0x0},
+	79: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	80: {lang: 0x48a, script: 0x5b, flags: 0x0},
+	81: {lang: 0x58, script: 0x5, flags: 0x0},
+	82: {lang: 0x219, script: 0x20, flags: 0x0},
+	83: {lang: 0x81, script: 0x34, flags: 0x0},
+	84: {lang: 0x529, script: 0x3c, flags: 0x0},
+	85: {lang: 0x48c, script: 0x5b, flags: 0x0},
+	86: {lang: 0x4ae, script: 0x20, flags: 0x0},
+	87: {lang: 0x512, script: 0x3e, flags: 0x0},
+	88: {lang: 0x3b3, script: 0x5b, flags: 0x0},
+	89: {lang: 0x431, script: 0x5b, flags: 0x0},
+	90: {lang: 0x432, script: 0x20, flags: 0x0},
+	91: {lang: 0x15e, script: 0x5b, flags: 0x0},
+	92: {lang: 0x446, script: 0x5, flags: 0x0},
+}
+
+type likelyTag struct {
+	lang   uint16
+	region uint16
+	script uint16
+}
+
+// Size: 198 bytes, 33 elements
+var likelyRegionGroup = [33]likelyTag{
+	1:  {lang: 0x139, region: 0xd7, script: 0x5b},
+	2:  {lang: 0x139, region: 0x136, script: 0x5b},
+	3:  {lang: 0x3c0, region: 0x41, script: 0x5b},
+	4:  {lang: 0x139, region: 0x2f, script: 0x5b},
+	5:  {lang: 0x139, region: 0xd7, script: 0x5b},
+	6:  {lang: 0x13e, region: 0xd0, script: 0x5b},
+	7:  {lang: 0x445, region: 0x130, script: 0x5b},
+	8:  {lang: 0x3a, region: 0x6c, script: 0x5},
+	9:  {lang: 0x445, region: 0x4b, script: 0x5b},
+	10: {lang: 0x139, region: 0x162, script: 0x5b},
+	11: {lang: 0x139, region: 0x136, script: 0x5b},
+	12: {lang: 0x139, region: 0x136, script: 0x5b},
+	13: {lang: 0x13e, region: 0x5a, script: 0x5b},
+	14: {lang: 0x529, region: 0x53, script: 0x3b},
+	15: {lang: 0x1be, region: 0x9a, script: 0x22},
+	16: {lang: 0x1e1, region: 0x96, script: 0x5b},
+	17: {lang: 0x1f9, region: 0x9f, script: 0x5b},
+	18: {lang: 0x139, region: 0x2f, script: 0x5b},
+	19: {lang: 0x139, region: 0xe7, script: 0x5b},
+	20: {lang: 0x139, region: 0x8b, script: 0x5b},
+	21: {lang: 0x41b, region: 0x143, script: 0x5b},
+	22: {lang: 0x529, region: 0x53, script: 0x3b},
+	23: {lang: 0x4bc, region: 0x138, script: 0x5b},
+	24: {lang: 0x3a, region: 0x109, script: 0x5},
+	25: {lang: 0x3e2, region: 0x107, script: 0x20},
+	26: {lang: 0x3e2, region: 0x107, script: 0x20},
+	27: {lang: 0x139, region: 0x7c, script: 0x5b},
+	28: {lang: 0x10d, region: 0x61, script: 0x5b},
+	29: {lang: 0x139, region: 0xd7, script: 0x5b},
+	30: {lang: 0x13e, region: 0x1f, script: 0x5b},
+	31: {lang: 0x139, region: 0x9b, script: 0x5b},
+	32: {lang: 0x139, region: 0x7c, script: 0x5b},
+}
+
+// Size: 264 bytes, 33 elements
+var regionContainment = [33]uint64{
+	// Entry 0 - 1F
+	0x00000001ffffffff, 0x00000000200007a2, 0x0000000000003044, 0x0000000000000008,
+	0x00000000803c0010, 0x0000000000000020, 0x0000000000000040, 0x0000000000000080,
+	0x0000000000000100, 0x0000000000000200, 0x0000000000000400, 0x000000004000384c,
+	0x0000000000001000, 0x0000000000002000, 0x0000000000004000, 0x0000000000008000,
+	0x0000000000010000, 0x0000000000020000, 0x0000000000040000, 0x0000000000080000,
+	0x0000000000100000, 0x0000000000200000, 0x0000000001c1c000, 0x0000000000800000,
+	0x0000000001000000, 0x000000001e020000, 0x0000000004000000, 0x0000000008000000,
+	0x0000000010000000, 0x00000000200006a0, 0x0000000040002048, 0x0000000080000000,
+	// Entry 20 - 3F
+	0x0000000100000000,
+}
+
+// regionInclusion maps region identifiers to sets of regions in regionInclusionBits,
+// where each set holds all groupings that are directly connected in a region
+// containment graph.
+// Size: 359 bytes, 359 elements
+var regionInclusion = [359]uint8{
+	// Entry 0 - 3F
+	0x00, 0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06,
+	0x07, 0x08, 0x09, 0x0a, 0x0b, 0x0c, 0x0d, 0x0e,
+	0x0f, 0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16,
+	0x17, 0x18, 0x19, 0x1a, 0x1b, 0x1c, 0x1d, 0x1e,
+	0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x26, 0x23,
+	0x24, 0x26, 0x27, 0x22, 0x28, 0x29, 0x2a, 0x2b,
+	0x26, 0x2c, 0x24, 0x23, 0x26, 0x25, 0x2a, 0x2d,
+	0x2e, 0x24, 0x2f, 0x2d, 0x26, 0x30, 0x31, 0x28,
+	// Entry 40 - 7F
+	0x26, 0x28, 0x26, 0x25, 0x31, 0x22, 0x32, 0x33,
+	0x34, 0x30, 0x22, 0x27, 0x27, 0x27, 0x35, 0x2d,
+	0x29, 0x28, 0x27, 0x36, 0x28, 0x22, 0x21, 0x34,
+	0x23, 0x21, 0x26, 0x2d, 0x26, 0x22, 0x37, 0x2e,
+	0x35, 0x2a, 0x22, 0x2f, 0x38, 0x26, 0x26, 0x21,
+	0x39, 0x39, 0x28, 0x38, 0x39, 0x39, 0x2f, 0x3a,
+	0x2f, 0x20, 0x21, 0x38, 0x3b, 0x28, 0x3c, 0x2c,
+	0x21, 0x2a, 0x35, 0x27, 0x38, 0x26, 0x24, 0x28,
+	// Entry 80 - BF
+	0x2c, 0x2d, 0x23, 0x30, 0x2d, 0x2d, 0x26, 0x27,
+	0x3a, 0x22, 0x34, 0x3c, 0x2d, 0x28, 0x36, 0x22,
+	0x34, 0x3a, 0x26, 0x2e, 0x21, 0x39, 0x31, 0x38,
+	0x24, 0x2c, 0x25, 0x22, 0x24, 0x25, 0x2c, 0x3a,
+	0x2c, 0x26, 0x24, 0x36, 0x21, 0x2f, 0x3d, 0x31,
+	0x3c, 0x2f, 0x26, 0x36, 0x36, 0x24, 0x26, 0x3d,
+	0x31, 0x24, 0x26, 0x35, 0x25, 0x2d, 0x32, 0x38,
+	0x2a, 0x38, 0x39, 0x39, 0x35, 0x33, 0x23, 0x26,
+	// Entry C0 - FF
+	0x2f, 0x3c, 0x21, 0x23, 0x2d, 0x31, 0x36, 0x36,
+	0x3c, 0x26, 0x2d, 0x26, 0x3a, 0x2f, 0x25, 0x2f,
+	0x34, 0x31, 0x2f, 0x32, 0x3b, 0x2d, 0x2b, 0x2d,
+	0x21, 0x34, 0x2a, 0x2c, 0x25, 0x21, 0x3c, 0x24,
+	0x29, 0x2b, 0x24, 0x34, 0x21, 0x28, 0x29, 0x3b,
+	0x31, 0x25, 0x2e, 0x30, 0x29, 0x26, 0x24, 0x3a,
+	0x21, 0x3c, 0x28, 0x21, 0x24, 0x21, 0x21, 0x1f,
+	0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
+	// Entry 100 - 13F
+	0x21, 0x21, 0x21, 0x2f, 0x21, 0x2e, 0x23, 0x33,
+	0x2f, 0x24, 0x3b, 0x2f, 0x39, 0x38, 0x31, 0x2d,
+	0x3a, 0x2c, 0x2e, 0x2d, 0x23, 0x2d, 0x2f, 0x28,
+	0x2f, 0x27, 0x33, 0x34, 0x26, 0x24, 0x32, 0x22,
+	0x26, 0x27, 0x22, 0x2d, 0x31, 0x3d, 0x29, 0x31,
+	0x3d, 0x39, 0x29, 0x31, 0x24, 0x26, 0x29, 0x36,
+	0x2f, 0x33, 0x2f, 0x21, 0x22, 0x21, 0x30, 0x28,
+	0x3d, 0x23, 0x26, 0x21, 0x28, 0x26, 0x26, 0x31,
+	// Entry 140 - 17F
+	0x3b, 0x29, 0x21, 0x29, 0x21, 0x21, 0x21, 0x21,
+	0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x23, 0x21,
+	0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x21,
+	0x21, 0x21, 0x21, 0x21, 0x21, 0x21, 0x24, 0x24,
+	0x2f, 0x23, 0x32, 0x2f, 0x27, 0x2f, 0x21,
+}
+
+// regionInclusionBits is an array of bit vectors where every vector represents
+// a set of region groupings.  These sets are used to compute the distance
+// between two regions for the purpose of language matching.
+// Size: 584 bytes, 73 elements
+var regionInclusionBits = [73]uint64{
+	// Entry 0 - 1F
+	0x0000000102400813, 0x00000000200007a3, 0x0000000000003844, 0x0000000040000808,
+	0x00000000803c0011, 0x0000000020000022, 0x0000000040000844, 0x0000000020000082,
+	0x0000000000000102, 0x0000000020000202, 0x0000000020000402, 0x000000004000384d,
+	0x0000000000001804, 0x0000000040002804, 0x0000000000404000, 0x0000000000408000,
+	0x0000000000410000, 0x0000000002020000, 0x0000000000040010, 0x0000000000080010,
+	0x0000000000100010, 0x0000000000200010, 0x0000000001c1c001, 0x0000000000c00000,
+	0x0000000001400000, 0x000000001e020001, 0x0000000006000000, 0x000000000a000000,
+	0x0000000012000000, 0x00000000200006a2, 0x0000000040002848, 0x0000000080000010,
+	// Entry 20 - 3F
+	0x0000000100000001, 0x0000000000000001, 0x0000000080000000, 0x0000000000020000,
+	0x0000000001000000, 0x0000000000008000, 0x0000000000002000, 0x0000000000000200,
+	0x0000000000000008, 0x0000000000200000, 0x0000000110000000, 0x0000000000040000,
+	0x0000000008000000, 0x0000000000000020, 0x0000000104000000, 0x0000000000000080,
+	0x0000000000001000, 0x0000000000010000, 0x0000000000000400, 0x0000000004000000,
+	0x0000000000000040, 0x0000000010000000, 0x0000000000004000, 0x0000000101000000,
+	0x0000000108000000, 0x0000000000000100, 0x0000000100020000, 0x0000000000080000,
+	0x0000000000100000, 0x0000000000800000, 0x00000001ffffffff, 0x0000000122400fb3,
+	// Entry 40 - 5F
+	0x00000001827c0813, 0x000000014240385f, 0x0000000103c1c813, 0x000000011e420813,
+	0x0000000112000001, 0x0000000106000001, 0x0000000101400001, 0x000000010a000001,
+	0x0000000102020001,
+}
+
+// regionInclusionNext marks, for each entry in regionInclusionBits, the set of
+// all groups that are reachable from the groups set in the respective entry.
+// Size: 73 bytes, 73 elements
+var regionInclusionNext = [73]uint8{
+	// Entry 0 - 3F
+	0x3e, 0x3f, 0x0b, 0x0b, 0x40, 0x01, 0x0b, 0x01,
+	0x01, 0x01, 0x01, 0x41, 0x0b, 0x0b, 0x16, 0x16,
+	0x16, 0x19, 0x04, 0x04, 0x04, 0x04, 0x42, 0x16,
+	0x16, 0x43, 0x19, 0x19, 0x19, 0x01, 0x0b, 0x04,
+	0x00, 0x00, 0x1f, 0x11, 0x18, 0x0f, 0x0d, 0x09,
+	0x03, 0x15, 0x44, 0x12, 0x1b, 0x05, 0x45, 0x07,
+	0x0c, 0x10, 0x0a, 0x1a, 0x06, 0x1c, 0x0e, 0x46,
+	0x47, 0x08, 0x48, 0x13, 0x14, 0x17, 0x3e, 0x3e,
+	// Entry 40 - 7F
+	0x3e, 0x3e, 0x3e, 0x3e, 0x43, 0x43, 0x42, 0x43,
+	0x43,
+}
+
+type parentRel struct {
+	lang       uint16
+	script     uint16
+	maxScript  uint16
+	toRegion   uint16
+	fromRegion []uint16
+}
+
+// Size: 414 bytes, 5 elements
+var parents = [5]parentRel{
+	0: {lang: 0x139, script: 0x0, maxScript: 0x5b, toRegion: 0x1, fromRegion: []uint16{0x1a, 0x25, 0x26, 0x2f, 0x34, 0x36, 0x3d, 0x42, 0x46, 0x48, 0x49, 0x4a, 0x50, 0x52, 0x5d, 0x5e, 0x62, 0x65, 0x6e, 0x74, 0x75, 0x76, 0x7c, 0x7d, 0x80, 0x81, 0x82, 0x84, 0x8d, 0x8e, 0x97, 0x98, 0x99, 0x9a, 0x9b, 0xa0, 0xa1, 0xa5, 0xa8, 0xaa, 0xae, 0xb2, 0xb5, 0xb6, 0xc0, 0xc7, 0xcb, 0xcc, 0xcd, 0xcf, 0xd1, 0xd3, 0xd6, 0xd7, 0xde, 0xe0, 0xe1, 0xe7, 0xe8, 0xe9, 0xec, 0xf1, 0x108, 0x10a, 0x10b, 0x10c, 0x10e, 0x10f, 0x113, 0x118, 0x11c, 0x11e, 0x120, 0x126, 0x12a, 0x12d, 0x12e, 0x130, 0x132, 0x13a, 0x13d, 0x140, 0x143, 0x162, 0x163, 0x165}},
+	1: {lang: 0x139, script: 0x0, maxScript: 0x5b, toRegion: 0x1a, fromRegion: []uint16{0x2e, 0x4e, 0x61, 0x64, 0x73, 0xda, 0x10d, 0x110}},
+	2: {lang: 0x13e, script: 0x0, maxScript: 0x5b, toRegion: 0x1f, fromRegion: []uint16{0x2c, 0x3f, 0x41, 0x48, 0x51, 0x54, 0x57, 0x5a, 0x66, 0x6a, 0x8a, 0x90, 0xd0, 0xd9, 0xe3, 0xe5, 0xed, 0xf2, 0x11b, 0x136, 0x137, 0x13c}},
+	3: {lang: 0x3c0, script: 0x0, maxScript: 0x5b, toRegion: 0xef, fromRegion: []uint16{0x2a, 0x4e, 0x5b, 0x87, 0x8c, 0xb8, 0xc7, 0xd2, 0x119, 0x127}},
+	4: {lang: 0x529, script: 0x3c, maxScript: 0x3c, toRegion: 0x8e, fromRegion: []uint16{0xc7}},
+}
+
+// Total table size 30466 bytes (29KiB); checksum: 7544152B
diff --git a/vendor/golang.org/x/text/internal/language/tags.go b/vendor/golang.org/x/text/internal/language/tags.go
new file mode 100644
index 00000000000..e7afd3188e6
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/language/tags.go
@@ -0,0 +1,48 @@
+// 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 language
+
+// MustParse is like Parse, but panics if the given BCP 47 tag cannot be parsed.
+// It simplifies safe initialization of Tag values.
+func MustParse(s string) Tag {
+	t, err := Parse(s)
+	if err != nil {
+		panic(err)
+	}
+	return t
+}
+
+// MustParseBase is like ParseBase, but panics if the given base cannot be parsed.
+// It simplifies safe initialization of Base values.
+func MustParseBase(s string) Language {
+	b, err := ParseBase(s)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}
+
+// MustParseScript is like ParseScript, but panics if the given script cannot be
+// parsed. It simplifies safe initialization of Script values.
+func MustParseScript(s string) Script {
+	scr, err := ParseScript(s)
+	if err != nil {
+		panic(err)
+	}
+	return scr
+}
+
+// MustParseRegion is like ParseRegion, but panics if the given region cannot be
+// parsed. It simplifies safe initialization of Region values.
+func MustParseRegion(s string) Region {
+	r, err := ParseRegion(s)
+	if err != nil {
+		panic(err)
+	}
+	return r
+}
+
+// Und is the root language.
+var Und Tag
diff --git a/vendor/golang.org/x/text/internal/match.go b/vendor/golang.org/x/text/internal/match.go
new file mode 100644
index 00000000000..1cc004a6d5f
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/match.go
@@ -0,0 +1,67 @@
+// Copyright 2015 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 internal
+
+// This file contains matchers that implement CLDR inheritance.
+//
+//     See https://unicode.org/reports/tr35/#Locale_Inheritance.
+//
+// Some of the inheritance described in this document is already handled by
+// the cldr package.
+
+import (
+	"golang.org/x/text/language"
+)
+
+// TODO: consider if (some of the) matching algorithm needs to be public after
+// getting some feel about what is generic and what is specific.
+
+// NewInheritanceMatcher returns a matcher that matches based on the inheritance
+// chain.
+//
+// The matcher uses canonicalization and the parent relationship to find a
+// match. The resulting match will always be either Und or a language with the
+// same language and script as the requested language. It will not match
+// languages for which there is understood to be mutual or one-directional
+// intelligibility.
+//
+// A Match will indicate an Exact match if the language matches after
+// canonicalization and High if the matched tag is a parent.
+func NewInheritanceMatcher(t []language.Tag) *InheritanceMatcher {
+	tags := &InheritanceMatcher{make(map[language.Tag]int)}
+	for i, tag := range t {
+		ct, err := language.All.Canonicalize(tag)
+		if err != nil {
+			ct = tag
+		}
+		tags.index[ct] = i
+	}
+	return tags
+}
+
+type InheritanceMatcher struct {
+	index map[language.Tag]int
+}
+
+func (m InheritanceMatcher) Match(want ...language.Tag) (language.Tag, int, language.Confidence) {
+	for _, t := range want {
+		ct, err := language.All.Canonicalize(t)
+		if err != nil {
+			ct = t
+		}
+		conf := language.Exact
+		for {
+			if index, ok := m.index[ct]; ok {
+				return ct, index, conf
+			}
+			if ct == language.Und {
+				break
+			}
+			ct = ct.Parent()
+			conf = language.High
+		}
+	}
+	return language.Und, 0, language.No
+}
diff --git a/vendor/golang.org/x/text/internal/tag/tag.go b/vendor/golang.org/x/text/internal/tag/tag.go
new file mode 100644
index 00000000000..b5d348891d8
--- /dev/null
+++ b/vendor/golang.org/x/text/internal/tag/tag.go
@@ -0,0 +1,100 @@
+// Copyright 2015 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 tag contains functionality handling tags and related data.
+package tag // import "golang.org/x/text/internal/tag"
+
+import "sort"
+
+// An Index converts tags to a compact numeric value.
+//
+// All elements are of size 4. Tags may be up to 4 bytes long. Excess bytes can
+// be used to store additional information about the tag.
+type Index string
+
+// Elem returns the element data at the given index.
+func (s Index) Elem(x int) string {
+	return string(s[x*4 : x*4+4])
+}
+
+// Index reports the index of the given key or -1 if it could not be found.
+// Only the first len(key) bytes from the start of the 4-byte entries will be
+// considered for the search and the first match in Index will be returned.
+func (s Index) Index(key []byte) int {
+	n := len(key)
+	// search the index of the first entry with an equal or higher value than
+	// key in s.
+	index := sort.Search(len(s)/4, func(i int) bool {
+		return cmp(s[i*4:i*4+n], key) != -1
+	})
+	i := index * 4
+	if cmp(s[i:i+len(key)], key) != 0 {
+		return -1
+	}
+	return index
+}
+
+// Next finds the next occurrence of key after index x, which must have been
+// obtained from a call to Index using the same key. It returns x+1 or -1.
+func (s Index) Next(key []byte, x int) int {
+	if x++; x*4 < len(s) && cmp(s[x*4:x*4+len(key)], key) == 0 {
+		return x
+	}
+	return -1
+}
+
+// cmp returns an integer comparing a and b lexicographically.
+func cmp(a Index, b []byte) int {
+	n := len(a)
+	if len(b) < n {
+		n = len(b)
+	}
+	for i, c := range b[:n] {
+		switch {
+		case a[i] > c:
+			return 1
+		case a[i] < c:
+			return -1
+		}
+	}
+	switch {
+	case len(a) < len(b):
+		return -1
+	case len(a) > len(b):
+		return 1
+	}
+	return 0
+}
+
+// Compare returns an integer comparing a and b lexicographically.
+func Compare(a string, b []byte) int {
+	return cmp(Index(a), b)
+}
+
+// FixCase reformats b to the same pattern of cases as form.
+// If returns false if string b is malformed.
+func FixCase(form string, b []byte) bool {
+	if len(form) != len(b) {
+		return false
+	}
+	for i, c := range b {
+		if form[i] <= 'Z' {
+			if c >= 'a' {
+				c -= 'z' - 'Z'
+			}
+			if c < 'A' || 'Z' < c {
+				return false
+			}
+		} else {
+			if c <= 'Z' {
+				c += 'z' - 'Z'
+			}
+			if c < 'a' || 'z' < c {
+				return false
+			}
+		}
+		b[i] = c
+	}
+	return true
+}
diff --git a/vendor/golang.org/x/text/language/coverage.go b/vendor/golang.org/x/text/language/coverage.go
new file mode 100644
index 00000000000..a24fd1a4d69
--- /dev/null
+++ b/vendor/golang.org/x/text/language/coverage.go
@@ -0,0 +1,187 @@
+// Copyright 2014 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 language
+
+import (
+	"fmt"
+	"sort"
+
+	"golang.org/x/text/internal/language"
+)
+
+// The Coverage interface is used to define the level of coverage of an
+// internationalization service. Note that not all types are supported by all
+// services. As lists may be generated on the fly, it is recommended that users
+// of a Coverage cache the results.
+type Coverage interface {
+	// Tags returns the list of supported tags.
+	Tags() []Tag
+
+	// BaseLanguages returns the list of supported base languages.
+	BaseLanguages() []Base
+
+	// Scripts returns the list of supported scripts.
+	Scripts() []Script
+
+	// Regions returns the list of supported regions.
+	Regions() []Region
+}
+
+var (
+	// Supported defines a Coverage that lists all supported subtags. Tags
+	// always returns nil.
+	Supported Coverage = allSubtags{}
+)
+
+// TODO:
+// - Support Variants, numbering systems.
+// - CLDR coverage levels.
+// - Set of common tags defined in this package.
+
+type allSubtags struct{}
+
+// Regions returns the list of supported regions. As all regions are in a
+// consecutive range, it simply returns a slice of numbers in increasing order.
+// The "undefined" region is not returned.
+func (s allSubtags) Regions() []Region {
+	reg := make([]Region, language.NumRegions)
+	for i := range reg {
+		reg[i] = Region{language.Region(i + 1)}
+	}
+	return reg
+}
+
+// Scripts returns the list of supported scripts. As all scripts are in a
+// consecutive range, it simply returns a slice of numbers in increasing order.
+// The "undefined" script is not returned.
+func (s allSubtags) Scripts() []Script {
+	scr := make([]Script, language.NumScripts)
+	for i := range scr {
+		scr[i] = Script{language.Script(i + 1)}
+	}
+	return scr
+}
+
+// BaseLanguages returns the list of all supported base languages. It generates
+// the list by traversing the internal structures.
+func (s allSubtags) BaseLanguages() []Base {
+	bs := language.BaseLanguages()
+	base := make([]Base, len(bs))
+	for i, b := range bs {
+		base[i] = Base{b}
+	}
+	return base
+}
+
+// Tags always returns nil.
+func (s allSubtags) Tags() []Tag {
+	return nil
+}
+
+// coverage is used by NewCoverage which is used as a convenient way for
+// creating Coverage implementations for partially defined data. Very often a
+// package will only need to define a subset of slices. coverage provides a
+// convenient way to do this. Moreover, packages using NewCoverage, instead of
+// their own implementation, will not break if later new slice types are added.
+type coverage struct {
+	tags    func() []Tag
+	bases   func() []Base
+	scripts func() []Script
+	regions func() []Region
+}
+
+func (s *coverage) Tags() []Tag {
+	if s.tags == nil {
+		return nil
+	}
+	return s.tags()
+}
+
+// bases implements sort.Interface and is used to sort base languages.
+type bases []Base
+
+func (b bases) Len() int {
+	return len(b)
+}
+
+func (b bases) Swap(i, j int) {
+	b[i], b[j] = b[j], b[i]
+}
+
+func (b bases) Less(i, j int) bool {
+	return b[i].langID < b[j].langID
+}
+
+// BaseLanguages returns the result from calling s.bases if it is specified or
+// otherwise derives the set of supported base languages from tags.
+func (s *coverage) BaseLanguages() []Base {
+	if s.bases == nil {
+		tags := s.Tags()
+		if len(tags) == 0 {
+			return nil
+		}
+		a := make([]Base, len(tags))
+		for i, t := range tags {
+			a[i] = Base{language.Language(t.lang())}
+		}
+		sort.Sort(bases(a))
+		k := 0
+		for i := 1; i < len(a); i++ {
+			if a[k] != a[i] {
+				k++
+				a[k] = a[i]
+			}
+		}
+		return a[:k+1]
+	}
+	return s.bases()
+}
+
+func (s *coverage) Scripts() []Script {
+	if s.scripts == nil {
+		return nil
+	}
+	return s.scripts()
+}
+
+func (s *coverage) Regions() []Region {
+	if s.regions == nil {
+		return nil
+	}
+	return s.regions()
+}
+
+// NewCoverage returns a Coverage for the given lists. It is typically used by
+// packages providing internationalization services to define their level of
+// coverage. A list may be of type []T or func() []T, where T is either Tag,
+// Base, Script or Region. The returned Coverage derives the value for Bases
+// from Tags if no func or slice for []Base is specified. For other unspecified
+// types the returned Coverage will return nil for the respective methods.
+func NewCoverage(list ...interface{}) Coverage {
+	s := &coverage{}
+	for _, x := range list {
+		switch v := x.(type) {
+		case func() []Base:
+			s.bases = v
+		case func() []Script:
+			s.scripts = v
+		case func() []Region:
+			s.regions = v
+		case func() []Tag:
+			s.tags = v
+		case []Base:
+			s.bases = func() []Base { return v }
+		case []Script:
+			s.scripts = func() []Script { return v }
+		case []Region:
+			s.regions = func() []Region { return v }
+		case []Tag:
+			s.tags = func() []Tag { return v }
+		default:
+			panic(fmt.Sprintf("language: unsupported set type %T", v))
+		}
+	}
+	return s
+}
diff --git a/vendor/golang.org/x/text/language/doc.go b/vendor/golang.org/x/text/language/doc.go
new file mode 100644
index 00000000000..212b77c9068
--- /dev/null
+++ b/vendor/golang.org/x/text/language/doc.go
@@ -0,0 +1,98 @@
+// Copyright 2017 The Go Authors. All rights reserved.
+// Use of this source code is governed by a BSD-style
+// license that can be found in the LICENSE file.
+
+// Package language implements BCP 47 language tags and related functionality.
+//
+// The most important function of package language is to match a list of
+// user-preferred languages to a list of supported languages.
+// It alleviates the developer of dealing with the complexity of this process
+// and provides the user with the best experience
+// (see https://blog.golang.org/matchlang).
+//
+// # Matching preferred against supported languages
+//
+// A Matcher for an application that supports English, Australian English,
+// Danish, and standard Mandarin can be created as follows:
+//
+//	var matcher = language.NewMatcher([]language.Tag{
+//	    language.English,   // The first language is used as fallback.
+//	    language.MustParse("en-AU"),
+//	    language.Danish,
+//	    language.Chinese,
+//	})
+//
+// This list of supported languages is typically implied by the languages for
+// which there exists translations of the user interface.
+//
+// User-preferred languages usually come as a comma-separated list of BCP 47
+// language tags.
+// The MatchString finds best matches for such strings:
+//
+//	handler(w http.ResponseWriter, r *http.Request) {
+//	    lang, _ := r.Cookie("lang")
+//	    accept := r.Header.Get("Accept-Language")
+//	    tag, _ := language.MatchStrings(matcher, lang.String(), accept)
+//
+//	    // tag should now be used for the initialization of any
+//	    // locale-specific service.
+//	}
+//
+// The Matcher's Match method can be used to match Tags directly.
+//
+// Matchers are aware of the intricacies of equivalence between languages, such
+// as deprecated subtags, legacy tags, macro languages, mutual
+// intelligibility between scripts and languages, and transparently passing
+// BCP 47 user configuration.
+// For instance, it will know that a reader of Bokmål Danish can read Norwegian
+// and will know that Cantonese ("yue") is a good match for "zh-HK".
+//
+// # Using match results
+//
+// To guarantee a consistent user experience to the user it is important to
+// use the same language tag for the selection of any locale-specific services.
+// For example, it is utterly confusing to substitute spelled-out numbers
+// or dates in one language in text of another language.
+// More subtly confusing is using the wrong sorting order or casing
+// algorithm for a certain language.
+//
+// All the packages in x/text that provide locale-specific services
+// (e.g. collate, cases) should be initialized with the tag that was
+// obtained at the start of an interaction with the user.
+//
+// Note that Tag that is returned by Match and MatchString may differ from any
+// of the supported languages, as it may contain carried over settings from
+// the user tags.
+// This may be inconvenient when your application has some additional
+// locale-specific data for your supported languages.
+// Match and MatchString both return the index of the matched supported tag
+// to simplify associating such data with the matched tag.
+//
+// # Canonicalization
+//
+// If one uses the Matcher to compare languages one does not need to
+// worry about canonicalization.
+//
+// The meaning of a Tag varies per application. The language package
+// therefore delays canonicalization and preserves information as much
+// as possible. The Matcher, however, will always take into account that
+// two different tags may represent the same language.
+//
+// By default, only legacy and deprecated tags are converted into their
+// canonical equivalent. All other information is preserved. This approach makes
+// the confidence scores more accurate and allows matchers to distinguish
+// between variants that are otherwise lost.
+//
+// As a consequence, two tags that should be treated as identical according to
+// BCP 47 or CLDR, like "en-Latn" and "en", will be represented differently. The
+// Matcher handles such distinctions, though, and is aware of the
+// equivalence relations. The CanonType type can be used to alter the
+// canonicalization form.
+//
+// # References
+//
+// BCP 47 - Tags for Identifying Languages http://tools.ietf.org/html/bcp47
+package language // import "golang.org/x/text/language"
+
+// TODO: explanation on how to match languages for your own locale-specific
+// service.
diff --git a/vendor/golang.org/x/text/language/language.go b/vendor/golang.org/x/text/language/language.go
new file mode 100644
index 00000000000..4d9c6612129
--- /dev/null
+++ b/vendor/golang.org/x/text/language/language.go
@@ -0,0 +1,605 @@
+// 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.
+
+//go:generate go run gen.go -output tables.go
+
+package language
+
+// TODO: Remove above NOTE after:
+// - verifying that tables are dropped correctly (most notably matcher tables).
+
+import (
+	"strings"
+
+	"golang.org/x/text/internal/language"
+	"golang.org/x/text/internal/language/compact"
+)
+
+// Tag represents a BCP 47 language tag. It is used to specify an instance of a
+// specific language or locale. All language tag values are guaranteed to be
+// well-formed.
+type Tag compact.Tag
+
+func makeTag(t language.Tag) (tag Tag) {
+	return Tag(compact.Make(t))
+}
+
+func (t *Tag) tag() language.Tag {
+	return (*compact.Tag)(t).Tag()
+}
+
+func (t *Tag) isCompact() bool {
+	return (*compact.Tag)(t).IsCompact()
+}
+
+// TODO: improve performance.
+func (t *Tag) lang() language.Language { return t.tag().LangID }
+func (t *Tag) region() language.Region { return t.tag().RegionID }
+func (t *Tag) script() language.Script { return t.tag().ScriptID }
+
+// Make is a convenience wrapper for Parse that omits the error.
+// In case of an error, a sensible default is returned.
+func Make(s string) Tag {
+	return Default.Make(s)
+}
+
+// Make is a convenience wrapper for c.Parse that omits the error.
+// In case of an error, a sensible default is returned.
+func (c CanonType) Make(s string) Tag {
+	t, _ := c.Parse(s)
+	return t
+}
+
+// Raw returns the raw base language, script and region, without making an
+// attempt to infer their values.
+func (t Tag) Raw() (b Base, s Script, r Region) {
+	tt := t.tag()
+	return Base{tt.LangID}, Script{tt.ScriptID}, Region{tt.RegionID}
+}
+
+// IsRoot returns true if t is equal to language "und".
+func (t Tag) IsRoot() bool {
+	return compact.Tag(t).IsRoot()
+}
+
+// CanonType can be used to enable or disable various types of canonicalization.
+type CanonType int
+
+const (
+	// Replace deprecated base languages with their preferred replacements.
+	DeprecatedBase CanonType = 1 << iota
+	// Replace deprecated scripts with their preferred replacements.
+	DeprecatedScript
+	// Replace deprecated regions with their preferred replacements.
+	DeprecatedRegion
+	// Remove redundant scripts.
+	SuppressScript
+	// Normalize legacy encodings. This includes legacy languages defined in
+	// CLDR as well as bibliographic codes defined in ISO-639.
+	Legacy
+	// Map the dominant language of a macro language group to the macro language
+	// subtag. For example cmn -> zh.
+	Macro
+	// The CLDR flag should be used if full compatibility with CLDR is required.
+	// There are a few cases where language.Tag may differ from CLDR. To follow all
+	// of CLDR's suggestions, use All|CLDR.
+	CLDR
+
+	// Raw can be used to Compose or Parse without Canonicalization.
+	Raw CanonType = 0
+
+	// Replace all deprecated tags with their preferred replacements.
+	Deprecated = DeprecatedBase | DeprecatedScript | DeprecatedRegion
+
+	// All canonicalizations recommended by BCP 47.
+	BCP47 = Deprecated | SuppressScript
+
+	// All canonicalizations.
+	All = BCP47 | Legacy | Macro
+
+	// Default is the canonicalization used by Parse, Make and Compose. To
+	// preserve as much information as possible, canonicalizations that remove
+	// potentially valuable information are not included. The Matcher is
+	// designed to recognize similar tags that would be the same if
+	// they were canonicalized using All.
+	Default = Deprecated | Legacy
+
+	canonLang = DeprecatedBase | Legacy | Macro
+
+	// TODO: LikelyScript, LikelyRegion: suppress similar to ICU.
+)
+
+// canonicalize returns the canonicalized equivalent of the tag and
+// whether there was any change.
+func canonicalize(c CanonType, t language.Tag) (language.Tag, bool) {
+	if c == Raw {
+		return t, false
+	}
+	changed := false
+	if c&SuppressScript != 0 {
+		if t.LangID.SuppressScript() == t.ScriptID {
+			t.ScriptID = 0
+			changed = true
+		}
+	}
+	if c&canonLang != 0 {
+		for {
+			if l, aliasType := t.LangID.Canonicalize(); l != t.LangID {
+				switch aliasType {
+				case language.Legacy:
+					if c&Legacy != 0 {
+						if t.LangID == _sh && t.ScriptID == 0 {
+							t.ScriptID = _Latn
+						}
+						t.LangID = l
+						changed = true
+					}
+				case language.Macro:
+					if c&Macro != 0 {
+						// We deviate here from CLDR. The mapping "nb" -> "no"
+						// qualifies as a typical Macro language mapping.  However,
+						// for legacy reasons, CLDR maps "no", the macro language
+						// code for Norwegian, to the dominant variant "nb". This
+						// change is currently under consideration for CLDR as well.
+						// See https://unicode.org/cldr/trac/ticket/2698 and also
+						// https://unicode.org/cldr/trac/ticket/1790 for some of the
+						// practical implications. TODO: this check could be removed
+						// if CLDR adopts this change.
+						if c&CLDR == 0 || t.LangID != _nb {
+							changed = true
+							t.LangID = l
+						}
+					}
+				case language.Deprecated:
+					if c&DeprecatedBase != 0 {
+						if t.LangID == _mo && t.RegionID == 0 {
+							t.RegionID = _MD
+						}
+						t.LangID = l
+						changed = true
+						// Other canonicalization types may still apply.
+						continue
+					}
+				}
+			} else if c&Legacy != 0 && t.LangID == _no && c&CLDR != 0 {
+				t.LangID = _nb
+				changed = true
+			}
+			break
+		}
+	}
+	if c&DeprecatedScript != 0 {
+		if t.ScriptID == _Qaai {
+			changed = true
+			t.ScriptID = _Zinh
+		}
+	}
+	if c&DeprecatedRegion != 0 {
+		if r := t.RegionID.Canonicalize(); r != t.RegionID {
+			changed = true
+			t.RegionID = r
+		}
+	}
+	return t, changed
+}
+
+// Canonicalize returns the canonicalized equivalent of the tag.
+func (c CanonType) Canonicalize(t Tag) (Tag, error) {
+	// First try fast path.
+	if t.isCompact() {
+		if _, changed := canonicalize(c, compact.Tag(t).Tag()); !changed {
+			return t, nil
+		}
+	}
+	// It is unlikely that one will canonicalize a tag after matching. So do
+	// a slow but simple approach here.
+	if tag, changed := canonicalize(c, t.tag()); changed {
+		tag.RemakeString()
+		return makeTag(tag), nil
+	}
+	return t, nil
+
+}
+
+// Confidence indicates the level of certainty for a given return value.
+// For example, Serbian may be written in Cyrillic or Latin script.
+// The confidence level indicates whether a value was explicitly specified,
+// whether it is typically the only possible value, or whether there is
+// an ambiguity.
+type Confidence int
+
+const (
+	No    Confidence = iota // full confidence that there was no match
+	Low                     // most likely value picked out of a set of alternatives
+	High                    // value is generally assumed to be the correct match
+	Exact                   // exact match or explicitly specified value
+)
+
+var confName = []string{"No", "Low", "High", "Exact"}
+
+func (c Confidence) String() string {
+	return confName[c]
+}
+
+// String returns the canonical string representation of the language tag.
+func (t Tag) String() string {
+	return t.tag().String()
+}
+
+// MarshalText implements encoding.TextMarshaler.
+func (t Tag) MarshalText() (text []byte, err error) {
+	return t.tag().MarshalText()
+}
+
+// UnmarshalText implements encoding.TextUnmarshaler.
+func (t *Tag) UnmarshalText(text []byte) error {
+	var tag language.Tag
+	err := tag.UnmarshalText(text)
+	*t = makeTag(tag)
+	return err
+}
+
+// Base returns the base language of the language tag. If the base language is
+// unspecified, an attempt will be made to infer it from the context.
+// It uses a variant of CLDR's Add Likely Subtags algorithm. This is subject to change.
+func (t Tag) Base() (Base, Confidence) {
+	if b := t.lang(); b != 0 {
+		return Base{b}, Exact
+	}
+	tt := t.tag()
+	c := High
+	if tt.ScriptID == 0 && !tt.RegionID.IsCountry() {
+		c = Low
+	}
+	if tag, err := tt.Maximize(); err == nil && tag.LangID != 0 {
+		return Base{tag.LangID}, c
+	}
+	return Base{0}, No
+}
+
+// Script infers the script for the language tag. If it was not explicitly given, it will infer
+// a most likely candidate.
+// If more than one script is commonly used for a language, the most likely one
+// is returned with a low confidence indication. For example, it returns (Cyrl, Low)
+// for Serbian.
+// If a script cannot be inferred (Zzzz, No) is returned. We do not use Zyyy (undetermined)
+// as one would suspect from the IANA registry for BCP 47. In a Unicode context Zyyy marks
+// common characters (like 1, 2, 3, '.', etc.) and is therefore more like multiple scripts.
+// See https://www.unicode.org/reports/tr24/#Values for more details. Zzzz is also used for
+// unknown value in CLDR.  (Zzzz, Exact) is returned if Zzzz was explicitly specified.
+// Note that an inferred script is never guaranteed to be the correct one. Latin is
+// almost exclusively used for Afrikaans, but Arabic has been used for some texts
+// in the past.  Also, the script that is commonly used may change over time.
+// It uses a variant of CLDR's Add Likely Subtags algorithm. This is subject to change.
+func (t Tag) Script() (Script, Confidence) {
+	if scr := t.script(); scr != 0 {
+		return Script{scr}, Exact
+	}
+	tt := t.tag()
+	sc, c := language.Script(_Zzzz), No
+	if scr := tt.LangID.SuppressScript(); scr != 0 {
+		// Note: it is not always the case that a language with a suppress
+		// script value is only written in one script (e.g. kk, ms, pa).
+		if tt.RegionID == 0 {
+			return Script{scr}, High
+		}
+		sc, c = scr, High
+	}
+	if tag, err := tt.Maximize(); err == nil {
+		if tag.ScriptID != sc {
+			sc, c = tag.ScriptID, Low
+		}
+	} else {
+		tt, _ = canonicalize(Deprecated|Macro, tt)
+		if tag, err := tt.Maximize(); err == nil && tag.ScriptID != sc {
+			sc, c = tag.ScriptID, Low
+		}
+	}
+	return Script{sc}, c
+}
+
+// Region returns the region for the language tag. If it was not explicitly given, it will
+// infer a most likely candidate from the context.
+// It uses a variant of CLDR's Add Likely Subtags algorithm. This is subject to change.
+func (t Tag) Region() (Region, Confidence) {
+	if r := t.region(); r != 0 {
+		return Region{r}, Exact
+	}
+	tt := t.tag()
+	if tt, err := tt.Maximize(); err == nil {
+		return Region{tt.RegionID}, Low // TODO: differentiate between high and low.
+	}
+	tt, _ = canonicalize(Deprecated|Macro, tt)
+	if tag, err := tt.Maximize(); err == nil {
+		return Region{tag.RegionID}, Low
+	}
+	return Region{_ZZ}, No // TODO: return world instead of undetermined?
+}
+
+// Variants returns the variants specified explicitly for this language tag.
+// or nil if no variant was specified.
+func (t Tag) Variants() []Variant {
+	if !compact.Tag(t).MayHaveVariants() {
+		return nil
+	}
+	v := []Variant{}
+	x, str := "", t.tag().Variants()
+	for str != "" {
+		x, str = nextToken(str)
+		v = append(v, Variant{x})
+	}
+	return v
+}
+
+// Parent returns the CLDR parent of t. In CLDR, missing fields in data for a
+// specific language are substituted with fields from the parent language.
+// The parent for a language may change for newer versions of CLDR.
+//
+// Parent returns a tag for a less specific language that is mutually
+// intelligible or Und if there is no such language. This may not be the same as
+// simply stripping the last BCP 47 subtag. For instance, the parent of "zh-TW"
+// is "zh-Hant", and the parent of "zh-Hant" is "und".
+func (t Tag) Parent() Tag {
+	return Tag(compact.Tag(t).Parent())
+}
+
+// nextToken returns token t and the rest of the string.
+func nextToken(s string) (t, tail string) {
+	p := strings.Index(s[1:], "-")
+	if p == -1 {
+		return s[1:], ""
+	}
+	p++
+	return s[1:p], s[p:]
+}
+
+// Extension is a single BCP 47 extension.
+type Extension struct {
+	s string
+}
+
+// String returns the string representation of the extension, including the
+// type tag.
+func (e Extension) String() string {
+	return e.s
+}
+
+// ParseExtension parses s as an extension and returns it on success.
+func ParseExtension(s string) (e Extension, err error) {
+	ext, err := language.ParseExtension(s)
+	return Extension{ext}, err
+}
+
+// Type returns the one-byte extension type of e. It returns 0 for the zero
+// exception.
+func (e Extension) Type() byte {
+	if e.s == "" {
+		return 0
+	}
+	return e.s[0]
+}
+
+// Tokens returns the list of tokens of e.
+func (e Extension) Tokens() []string {
+	return strings.Split(e.s, "-")
+}
+
+// Extension returns the extension of type x for tag t. It will return
+// false for ok if t does not have the requested extension. The returned
+// extension will be invalid in this case.
+func (t Tag) Extension(x byte) (ext Extension, ok bool) {
+	if !compact.Tag(t).MayHaveExtensions() {
+		return Extension{}, false
+	}
+	e, ok := t.tag().Extension(x)
+	return Extension{e}, ok
+}
+
+// Extensions returns all extensions of t.
+func (t Tag) Extensions() []Extension {
+	if !compact.Tag(t).MayHaveExtensions() {
+		return nil
+	}
+	e := []Extension{}
+	for _, ext := range t.tag().Extensions() {
+		e = append(e, Extension{ext})
+	}
+	return e
+}
+
+// TypeForKey returns the type associated with the given key, where key and type
+// are of the allowed values defined for the Unicode locale extension ('u') in
+// https://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers.
+// TypeForKey will traverse the inheritance chain to get the correct value.
+//
+// If there are multiple types associated with a key, only the first will be
+// returned. If there is no type associated with a key, it returns the empty
+// string.
+func (t Tag) TypeForKey(key string) string {
+	if !compact.Tag(t).MayHaveExtensions() {
+		if key != "rg" && key != "va" {
+			return ""
+		}
+	}
+	return t.tag().TypeForKey(key)
+}
+
+// SetTypeForKey returns a new Tag with the key set to type, where key and type
+// are of the allowed values defined for the Unicode locale extension ('u') in
+// https://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers.
+// An empty value removes an existing pair with the same key.
+func (t Tag) SetTypeForKey(key, value string) (Tag, error) {
+	tt, err := t.tag().SetTypeForKey(key, value)
+	return makeTag(tt), err
+}
+
+// NumCompactTags is the number of compact tags. The maximum tag is
+// NumCompactTags-1.
+const NumCompactTags = compact.NumCompactTags
+
+// CompactIndex returns an index, where 0 <= index < NumCompactTags, for tags
+// for which data exists in the text repository.The index will change over time
+// and should not be stored in persistent storage. If t does not match a compact
+// index, exact will be false and the compact index will be returned for the
+// first match after repeatedly taking the Parent of t.
+func CompactIndex(t Tag) (index int, exact bool) {
+	id, exact := compact.LanguageID(compact.Tag(t))
+	return int(id), exact
+}
+
+var root = language.Tag{}
+
+// Base is an ISO 639 language code, used for encoding the base language
+// of a language tag.
+type Base struct {
+	langID language.Language
+}
+
+// ParseBase parses a 2- or 3-letter ISO 639 code.
+// It returns a ValueError if s is a well-formed but unknown language identifier
+// or another error if another error occurred.
+func ParseBase(s string) (Base, error) {
+	l, err := language.ParseBase(s)
+	return Base{l}, err
+}
+
+// String returns the BCP 47 representation of the base language.
+func (b Base) String() string {
+	return b.langID.String()
+}
+
+// ISO3 returns the ISO 639-3 language code.
+func (b Base) ISO3() string {
+	return b.langID.ISO3()
+}
+
+// IsPrivateUse reports whether this language code is reserved for private use.
+func (b Base) IsPrivateUse() bool {
+	return b.langID.IsPrivateUse()
+}
+
+// Script is a 4-letter ISO 15924 code for representing scripts.
+// It is idiomatically represented in title case.
+type Script struct {
+	scriptID language.Script
+}
+
+// ParseScript parses a 4-letter ISO 15924 code.
+// It returns a ValueError if s is a well-formed but unknown script identifier
+// or another error if another error occurred.
+func ParseScript(s string) (Script, error) {
+	sc, err := language.ParseScript(s)
+	return Script{sc}, err
+}
+
+// String returns the script code in title case.
+// It returns "Zzzz" for an unspecified script.
+func (s Script) String() string {
+	return s.scriptID.String()
+}
+
+// IsPrivateUse reports whether this script code is reserved for private use.
+func (s Script) IsPrivateUse() bool {
+	return s.scriptID.IsPrivateUse()
+}
+
+// Region is an ISO 3166-1 or UN M.49 code for representing countries and regions.
+type Region struct {
+	regionID language.Region
+}
+
+// EncodeM49 returns the Region for the given UN M.49 code.
+// It returns an error if r is not a valid code.
+func EncodeM49(r int) (Region, error) {
+	rid, err := language.EncodeM49(r)
+	return Region{rid}, err
+}
+
+// ParseRegion parses a 2- or 3-letter ISO 3166-1 or a UN M.49 code.
+// It returns a ValueError if s is a well-formed but unknown region identifier
+// or another error if another error occurred.
+func ParseRegion(s string) (Region, error) {
+	r, err := language.ParseRegion(s)
+	return Region{r}, err
+}
+
+// String returns the BCP 47 representation for the region.
+// It returns "ZZ" for an unspecified region.
+func (r Region) String() string {
+	return r.regionID.String()
+}
+
+// ISO3 returns the 3-letter ISO code of r.
+// Note that not all regions have a 3-letter ISO code.
+// In such cases this method returns "ZZZ".
+func (r Region) ISO3() string {
+	return r.regionID.ISO3()
+}
+
+// M49 returns the UN M.49 encoding of r, or 0 if this encoding
+// is not defined for r.
+func (r Region) M49() int {
+	return r.regionID.M49()
+}
+
+// IsPrivateUse reports whether r has the ISO 3166 User-assigned status. This
+// may include private-use tags that are assigned by CLDR and used in this
+// implementation. So IsPrivateUse and IsCountry can be simultaneously true.
+func (r Region) IsPrivateUse() bool {
+	return r.regionID.IsPrivateUse()
+}
+
+// IsCountry returns whether this region is a country or autonomous area. This
+// includes non-standard definitions from CLDR.
+func (r Region) IsCountry() bool {
+	return r.regionID.IsCountry()
+}
+
+// IsGroup returns whether this region defines a collection of regions. This
+// includes non-standard definitions from CLDR.
+func (r Region) IsGroup() bool {
+	return r.regionID.IsGroup()
+}
+
+// Contains returns whether Region c is contained by Region r. It returns true
+// if c == r.
+func (r Region) Contains(c Region) bool {
+	return r.regionID.Contains(c.regionID)
+}
+
+// TLD returns the country code top-level domain (ccTLD). UK is returned for GB.
+// In all other cases it returns either the region itself or an error.
+//
+// This method may return an error for a region for which there exists a
+// canonical form with a ccTLD. To get that ccTLD canonicalize r first. The
+// region will already be canonicalized it was obtained from a Tag that was
+// obtained using any of the default methods.
+func (r Region) TLD() (Region, error) {
+	tld, err := r.regionID.TLD()
+	return Region{tld}, err
+}
+
+// Canonicalize returns the region or a possible replacement if the region is
+// deprecated. It will not return a replacement for deprecated regions that
+// are split into multiple regions.
+func (r Region) Canonicalize() Region {
+	return Region{r.regionID.Canonicalize()}
+}
+
+// Variant represents a registered variant of a language as defined by BCP 47.
+type Variant struct {
+	variant string
+}
+
+// ParseVariant parses and returns a Variant. An error is returned if s is not
+// a valid variant.
+func ParseVariant(s string) (Variant, error) {
+	v, err := language.ParseVariant(s)
+	return Variant{v.String()}, err
+}
+
+// String returns the string representation of the variant.
+func (v Variant) String() string {
+	return v.variant
+}
diff --git a/vendor/golang.org/x/text/language/match.go b/vendor/golang.org/x/text/language/match.go
new file mode 100644
index 00000000000..1153baf291c
--- /dev/null
+++ b/vendor/golang.org/x/text/language/match.go
@@ -0,0 +1,735 @@
+// 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 language
+
+import (
+	"errors"
+	"strings"
+
+	"golang.org/x/text/internal/language"
+)
+
+// A MatchOption configures a Matcher.
+type MatchOption func(*matcher)
+
+// PreferSameScript will, in the absence of a match, result in the first
+// preferred tag with the same script as a supported tag to match this supported
+// tag. The default is currently true, but this may change in the future.
+func PreferSameScript(preferSame bool) MatchOption {
+	return func(m *matcher) { m.preferSameScript = preferSame }
+}
+
+// TODO(v1.0.0): consider making Matcher a concrete type, instead of interface.
+// There doesn't seem to be too much need for multiple types.
+// Making it a concrete type allows MatchStrings to be a method, which will
+// improve its discoverability.
+
+// MatchStrings parses and matches the given strings until one of them matches
+// the language in the Matcher. A string may be an Accept-Language header as
+// handled by ParseAcceptLanguage. The default language is returned if no
+// other language matched.
+func MatchStrings(m Matcher, lang ...string) (tag Tag, index int) {
+	for _, accept := range lang {
+		desired, _, err := ParseAcceptLanguage(accept)
+		if err != nil {
+			continue
+		}
+		if tag, index, conf := m.Match(desired...); conf != No {
+			return tag, index
+		}
+	}
+	tag, index, _ = m.Match()
+	return
+}
+
+// Matcher is the interface that wraps the Match method.
+//
+// Match returns the best match for any of the given tags, along with
+// a unique index associated with the returned tag and a confidence
+// score.
+type Matcher interface {
+	Match(t ...Tag) (tag Tag, index int, c Confidence)
+}
+
+// Comprehends reports the confidence score for a speaker of a given language
+// to being able to comprehend the written form of an alternative language.
+func Comprehends(speaker, alternative Tag) Confidence {
+	_, _, c := NewMatcher([]Tag{alternative}).Match(speaker)
+	return c
+}
+
+// NewMatcher returns a Matcher that matches an ordered list of preferred tags
+// against a list of supported tags based on written intelligibility, closeness
+// of dialect, equivalence of subtags and various other rules. It is initialized
+// with the list of supported tags. The first element is used as the default
+// value in case no match is found.
+//
+// Its Match method matches the first of the given Tags to reach a certain
+// confidence threshold. The tags passed to Match should therefore be specified
+// in order of preference. Extensions are ignored for matching.
+//
+// The index returned by the Match method corresponds to the index of the
+// matched tag in t, but is augmented with the Unicode extension ('u')of the
+// corresponding preferred tag. This allows user locale options to be passed
+// transparently.
+func NewMatcher(t []Tag, options ...MatchOption) Matcher {
+	return newMatcher(t, options)
+}
+
+func (m *matcher) Match(want ...Tag) (t Tag, index int, c Confidence) {
+	var tt language.Tag
+	match, w, c := m.getBest(want...)
+	if match != nil {
+		tt, index = match.tag, match.index
+	} else {
+		// TODO: this should be an option
+		tt = m.default_.tag
+		if m.preferSameScript {
+		outer:
+			for _, w := range want {
+				script, _ := w.Script()
+				if script.scriptID == 0 {
+					// Don't do anything if there is no script, such as with
+					// private subtags.
+					continue
+				}
+				for i, h := range m.supported {
+					if script.scriptID == h.maxScript {
+						tt, index = h.tag, i
+						break outer
+					}
+				}
+			}
+		}
+		// TODO: select first language tag based on script.
+	}
+	if w.RegionID != tt.RegionID && w.RegionID != 0 {
+		if w.RegionID != 0 && tt.RegionID != 0 && tt.RegionID.Contains(w.RegionID) {
+			tt.RegionID = w.RegionID
+			tt.RemakeString()
+		} else if r := w.RegionID.String(); len(r) == 2 {
+			// TODO: also filter macro and deprecated.
+			tt, _ = tt.SetTypeForKey("rg", strings.ToLower(r)+"zzzz")
+		}
+	}
+	// Copy options from the user-provided tag into the result tag. This is hard
+	// to do after the fact, so we do it here.
+	// TODO: add in alternative variants to -u-va-.
+	// TODO: add preferred region to -u-rg-.
+	if e := w.Extensions(); len(e) > 0 {
+		b := language.Builder{}
+		b.SetTag(tt)
+		for _, e := range e {
+			b.AddExt(e)
+		}
+		tt = b.Make()
+	}
+	return makeTag(tt), index, c
+}
+
+// ErrMissingLikelyTagsData indicates no information was available
+// to compute likely values of missing tags.
+var ErrMissingLikelyTagsData = errors.New("missing likely tags data")
+
+// func (t *Tag) setTagsFrom(id Tag) {
+// 	t.LangID = id.LangID
+// 	t.ScriptID = id.ScriptID
+// 	t.RegionID = id.RegionID
+// }
+
+// Tag Matching
+// CLDR defines an algorithm for finding the best match between two sets of language
+// tags. The basic algorithm defines how to score a possible match and then find
+// the match with the best score
+// (see https://www.unicode.org/reports/tr35/#LanguageMatching).
+// Using scoring has several disadvantages. The scoring obfuscates the importance of
+// the various factors considered, making the algorithm harder to understand. Using
+// scoring also requires the full score to be computed for each pair of tags.
+//
+// We will use a different algorithm which aims to have the following properties:
+// - clarity on the precedence of the various selection factors, and
+// - improved performance by allowing early termination of a comparison.
+//
+// Matching algorithm (overview)
+// Input:
+//   - supported: a set of supported tags
+//   - default:   the default tag to return in case there is no match
+//   - desired:   list of desired tags, ordered by preference, starting with
+//                the most-preferred.
+//
+// Algorithm:
+//   1) Set the best match to the lowest confidence level
+//   2) For each tag in "desired":
+//     a) For each tag in "supported":
+//        1) compute the match between the two tags.
+//        2) if the match is better than the previous best match, replace it
+//           with the new match. (see next section)
+//     b) if the current best match is Exact and pin is true the result will be
+//        frozen to the language found thusfar, although better matches may
+//        still be found for the same language.
+//   3) If the best match so far is below a certain threshold, return "default".
+//
+// Ranking:
+// We use two phases to determine whether one pair of tags are a better match
+// than another pair of tags. First, we determine a rough confidence level. If the
+// levels are different, the one with the highest confidence wins.
+// Second, if the rough confidence levels are identical, we use a set of tie-breaker
+// rules.
+//
+// The confidence level of matching a pair of tags is determined by finding the
+// lowest confidence level of any matches of the corresponding subtags (the
+// result is deemed as good as its weakest link).
+// We define the following levels:
+//   Exact    - An exact match of a subtag, before adding likely subtags.
+//   MaxExact - An exact match of a subtag, after adding likely subtags.
+//              [See Note 2].
+//   High     - High level of mutual intelligibility between different subtag
+//              variants.
+//   Low      - Low level of mutual intelligibility between different subtag
+//              variants.
+//   No       - No mutual intelligibility.
+//
+// The following levels can occur for each type of subtag:
+//   Base:    Exact, MaxExact, High, Low, No
+//   Script:  Exact, MaxExact [see Note 3], Low, No
+//   Region:  Exact, MaxExact, High
+//   Variant: Exact, High
+//   Private: Exact, No
+//
+// Any result with a confidence level of Low or higher is deemed a possible match.
+// Once a desired tag matches any of the supported tags with a level of MaxExact
+// or higher, the next desired tag is not considered (see Step 2.b).
+// Note that CLDR provides languageMatching data that defines close equivalence
+// classes for base languages, scripts and regions.
+//
+// Tie-breaking
+// If we get the same confidence level for two matches, we apply a sequence of
+// tie-breaking rules. The first that succeeds defines the result. The rules are
+// applied in the following order.
+//   1) Original language was defined and was identical.
+//   2) Original region was defined and was identical.
+//   3) Distance between two maximized regions was the smallest.
+//   4) Original script was defined and was identical.
+//   5) Distance from want tag to have tag using the parent relation [see Note 5.]
+// If there is still no winner after these rules are applied, the first match
+// found wins.
+//
+// Notes:
+// [2] In practice, as matching of Exact is done in a separate phase from
+//     matching the other levels, we reuse the Exact level to mean MaxExact in
+//     the second phase. As a consequence, we only need the levels defined by
+//     the Confidence type. The MaxExact confidence level is mapped to High in
+//     the public API.
+// [3] We do not differentiate between maximized script values that were derived
+//     from suppressScript versus most likely tag data. We determined that in
+//     ranking the two, one ranks just after the other. Moreover, the two cannot
+//     occur concurrently. As a consequence, they are identical for practical
+//     purposes.
+// [4] In case of deprecated, macro-equivalents and legacy mappings, we assign
+//     the MaxExact level to allow iw vs he to still be a closer match than
+//     en-AU vs en-US, for example.
+// [5] In CLDR a locale inherits fields that are unspecified for this locale
+//     from its parent. Therefore, if a locale is a parent of another locale,
+//     it is a strong measure for closeness, especially when no other tie
+//     breaker rule applies. One could also argue it is inconsistent, for
+//     example, when pt-AO matches pt (which CLDR equates with pt-BR), even
+//     though its parent is pt-PT according to the inheritance rules.
+//
+// Implementation Details:
+// There are several performance considerations worth pointing out. Most notably,
+// we preprocess as much as possible (within reason) at the time of creation of a
+// matcher. This includes:
+//   - creating a per-language map, which includes data for the raw base language
+//     and its canonicalized variant (if applicable),
+//   - expanding entries for the equivalence classes defined in CLDR's
+//     languageMatch data.
+// The per-language map ensures that typically only a very small number of tags
+// need to be considered. The pre-expansion of canonicalized subtags and
+// equivalence classes reduces the amount of map lookups that need to be done at
+// runtime.
+
+// matcher keeps a set of supported language tags, indexed by language.
+type matcher struct {
+	default_         *haveTag
+	supported        []*haveTag
+	index            map[language.Language]*matchHeader
+	passSettings     bool
+	preferSameScript bool
+}
+
+// matchHeader has the lists of tags for exact matches and matches based on
+// maximized and canonicalized tags for a given language.
+type matchHeader struct {
+	haveTags []*haveTag
+	original bool
+}
+
+// haveTag holds a supported Tag and its maximized script and region. The maximized
+// or canonicalized language is not stored as it is not needed during matching.
+type haveTag struct {
+	tag language.Tag
+
+	// index of this tag in the original list of supported tags.
+	index int
+
+	// conf is the maximum confidence that can result from matching this haveTag.
+	// When conf < Exact this means it was inserted after applying a CLDR equivalence rule.
+	conf Confidence
+
+	// Maximized region and script.
+	maxRegion language.Region
+	maxScript language.Script
+
+	// altScript may be checked as an alternative match to maxScript. If altScript
+	// matches, the confidence level for this match is Low. Theoretically there
+	// could be multiple alternative scripts. This does not occur in practice.
+	altScript language.Script
+
+	// nextMax is the index of the next haveTag with the same maximized tags.
+	nextMax uint16
+}
+
+func makeHaveTag(tag language.Tag, index int) (haveTag, language.Language) {
+	max := tag
+	if tag.LangID != 0 || tag.RegionID != 0 || tag.ScriptID != 0 {
+		max, _ = canonicalize(All, max)
+		max, _ = max.Maximize()
+		max.RemakeString()
+	}
+	return haveTag{tag, index, Exact, max.RegionID, max.ScriptID, altScript(max.LangID, max.ScriptID), 0}, max.LangID
+}
+
+// altScript returns an alternative script that may match the given script with
+// a low confidence.  At the moment, the langMatch data allows for at most one
+// script to map to another and we rely on this to keep the code simple.
+func altScript(l language.Language, s language.Script) language.Script {
+	for _, alt := range matchScript {
+		// TODO: also match cases where language is not the same.
+		if (language.Language(alt.wantLang) == l || language.Language(alt.haveLang) == l) &&
+			language.Script(alt.haveScript) == s {
+			return language.Script(alt.wantScript)
+		}
+	}
+	return 0
+}
+
+// addIfNew adds a haveTag to the list of tags only if it is a unique tag.
+// Tags that have the same maximized values are linked by index.
+func (h *matchHeader) addIfNew(n haveTag, exact bool) {
+	h.original = h.original || exact
+	// Don't add new exact matches.
+	for _, v := range h.haveTags {
+		if equalsRest(v.tag, n.tag) {
+			return
+		}
+	}
+	// Allow duplicate maximized tags, but create a linked list to allow quickly
+	// comparing the equivalents and bail out.
+	for i, v := range h.haveTags {
+		if v.maxScript == n.maxScript &&
+			v.maxRegion == n.maxRegion &&
+			v.tag.VariantOrPrivateUseTags() == n.tag.VariantOrPrivateUseTags() {
+			for h.haveTags[i].nextMax != 0 {
+				i = int(h.haveTags[i].nextMax)
+			}
+			h.haveTags[i].nextMax = uint16(len(h.haveTags))
+			break
+		}
+	}
+	h.haveTags = append(h.haveTags, &n)
+}
+
+// header returns the matchHeader for the given language. It creates one if
+// it doesn't already exist.
+func (m *matcher) header(l language.Language) *matchHeader {
+	if h := m.index[l]; h != nil {
+		return h
+	}
+	h := &matchHeader{}
+	m.index[l] = h
+	return h
+}
+
+func toConf(d uint8) Confidence {
+	if d <= 10 {
+		return High
+	}
+	if d < 30 {
+		return Low
+	}
+	return No
+}
+
+// newMatcher builds an index for the given supported tags and returns it as
+// a matcher. It also expands the index by considering various equivalence classes
+// for a given tag.
+func newMatcher(supported []Tag, options []MatchOption) *matcher {
+	m := &matcher{
+		index:            make(map[language.Language]*matchHeader),
+		preferSameScript: true,
+	}
+	for _, o := range options {
+		o(m)
+	}
+	if len(supported) == 0 {
+		m.default_ = &haveTag{}
+		return m
+	}
+	// Add supported languages to the index. Add exact matches first to give
+	// them precedence.
+	for i, tag := range supported {
+		tt := tag.tag()
+		pair, _ := makeHaveTag(tt, i)
+		m.header(tt.LangID).addIfNew(pair, true)
+		m.supported = append(m.supported, &pair)
+	}
+	m.default_ = m.header(supported[0].lang()).haveTags[0]
+	// Keep these in two different loops to support the case that two equivalent
+	// languages are distinguished, such as iw and he.
+	for i, tag := range supported {
+		tt := tag.tag()
+		pair, max := makeHaveTag(tt, i)
+		if max != tt.LangID {
+			m.header(max).addIfNew(pair, true)
+		}
+	}
+
+	// update is used to add indexes in the map for equivalent languages.
+	// update will only add entries to original indexes, thus not computing any
+	// transitive relations.
+	update := func(want, have uint16, conf Confidence) {
+		if hh := m.index[language.Language(have)]; hh != nil {
+			if !hh.original {
+				return
+			}
+			hw := m.header(language.Language(want))
+			for _, ht := range hh.haveTags {
+				v := *ht
+				if conf < v.conf {
+					v.conf = conf
+				}
+				v.nextMax = 0 // this value needs to be recomputed
+				if v.altScript != 0 {
+					v.altScript = altScript(language.Language(want), v.maxScript)
+				}
+				hw.addIfNew(v, conf == Exact && hh.original)
+			}
+		}
+	}
+
+	// Add entries for languages with mutual intelligibility as defined by CLDR's
+	// languageMatch data.
+	for _, ml := range matchLang {
+		update(ml.want, ml.have, toConf(ml.distance))
+		if !ml.oneway {
+			update(ml.have, ml.want, toConf(ml.distance))
+		}
+	}
+
+	// Add entries for possible canonicalizations. This is an optimization to
+	// ensure that only one map lookup needs to be done at runtime per desired tag.
+	// First we match deprecated equivalents. If they are perfect equivalents
+	// (their canonicalization simply substitutes a different language code, but
+	// nothing else), the match confidence is Exact, otherwise it is High.
+	for i, lm := range language.AliasMap {
+		// If deprecated codes match and there is no fiddling with the script
+		// or region, we consider it an exact match.
+		conf := Exact
+		if language.AliasTypes[i] != language.Macro {
+			if !isExactEquivalent(language.Language(lm.From)) {
+				conf = High
+			}
+			update(lm.To, lm.From, conf)
+		}
+		update(lm.From, lm.To, conf)
+	}
+	return m
+}
+
+// getBest gets the best matching tag in m for any of the given tags, taking into
+// account the order of preference of the given tags.
+func (m *matcher) getBest(want ...Tag) (got *haveTag, orig language.Tag, c Confidence) {
+	best := bestMatch{}
+	for i, ww := range want {
+		w := ww.tag()
+		var max language.Tag
+		// Check for exact match first.
+		h := m.index[w.LangID]
+		if w.LangID != 0 {
+			if h == nil {
+				continue
+			}
+			// Base language is defined.
+			max, _ = canonicalize(Legacy|Deprecated|Macro, w)
+			// A region that is added through canonicalization is stronger than
+			// a maximized region: set it in the original (e.g. mo -> ro-MD).
+			if w.RegionID != max.RegionID {
+				w.RegionID = max.RegionID
+			}
+			// TODO: should we do the same for scripts?
+			// See test case: en, sr, nl ; sh ; sr
+			max, _ = max.Maximize()
+		} else {
+			// Base language is not defined.
+			if h != nil {
+				for i := range h.haveTags {
+					have := h.haveTags[i]
+					if equalsRest(have.tag, w) {
+						return have, w, Exact
+					}
+				}
+			}
+			if w.ScriptID == 0 && w.RegionID == 0 {
+				// We skip all tags matching und for approximate matching, including
+				// private tags.
+				continue
+			}
+			max, _ = w.Maximize()
+			if h = m.index[max.LangID]; h == nil {
+				continue
+			}
+		}
+		pin := true
+		for _, t := range want[i+1:] {
+			if w.LangID == t.lang() {
+				pin = false
+				break
+			}
+		}
+		// Check for match based on maximized tag.
+		for i := range h.haveTags {
+			have := h.haveTags[i]
+			best.update(have, w, max.ScriptID, max.RegionID, pin)
+			if best.conf == Exact {
+				for have.nextMax != 0 {
+					have = h.haveTags[have.nextMax]
+					best.update(have, w, max.ScriptID, max.RegionID, pin)
+				}
+				return best.have, best.want, best.conf
+			}
+		}
+	}
+	if best.conf <= No {
+		if len(want) != 0 {
+			return nil, want[0].tag(), No
+		}
+		return nil, language.Tag{}, No
+	}
+	return best.have, best.want, best.conf
+}
+
+// bestMatch accumulates the best match so far.
+type bestMatch struct {
+	have            *haveTag
+	want            language.Tag
+	conf            Confidence
+	pinnedRegion    language.Region
+	pinLanguage     bool
+	sameRegionGroup bool
+	// Cached results from applying tie-breaking rules.
+	origLang     bool
+	origReg      bool
+	paradigmReg  bool
+	regGroupDist uint8
+	origScript   bool
+}
+
+// update updates the existing best match if the new pair is considered to be a
+// better match. To determine if the given pair is a better match, it first
+// computes the rough confidence level. If this surpasses the current match, it
+// will replace it and update the tie-breaker rule cache. If there is a tie, it
+// proceeds with applying a series of tie-breaker rules. If there is no
+// conclusive winner after applying the tie-breaker rules, it leaves the current
+// match as the preferred match.
+//
+// If pin is true and have and tag are a strong match, it will henceforth only
+// consider matches for this language. This corresponds to the idea that most
+// users have a strong preference for the first defined language. A user can
+// still prefer a second language over a dialect of the preferred language by
+// explicitly specifying dialects, e.g. "en, nl, en-GB". In this case pin should
+// be false.
+func (m *bestMatch) update(have *haveTag, tag language.Tag, maxScript language.Script, maxRegion language.Region, pin bool) {
+	// Bail if the maximum attainable confidence is below that of the current best match.
+	c := have.conf
+	if c < m.conf {
+		return
+	}
+	// Don't change the language once we already have found an exact match.
+	if m.pinLanguage && tag.LangID != m.want.LangID {
+		return
+	}
+	// Pin the region group if we are comparing tags for the same language.
+	if tag.LangID == m.want.LangID && m.sameRegionGroup {
+		_, sameGroup := regionGroupDist(m.pinnedRegion, have.maxRegion, have.maxScript, m.want.LangID)
+		if !sameGroup {
+			return
+		}
+	}
+	if c == Exact && have.maxScript == maxScript {
+		// If there is another language and then another entry of this language,
+		// don't pin anything, otherwise pin the language.
+		m.pinLanguage = pin
+	}
+	if equalsRest(have.tag, tag) {
+	} else if have.maxScript != maxScript {
+		// There is usually very little comprehension between different scripts.
+		// In a few cases there may still be Low comprehension. This possibility
+		// is pre-computed and stored in have.altScript.
+		if Low < m.conf || have.altScript != maxScript {
+			return
+		}
+		c = Low
+	} else if have.maxRegion != maxRegion {
+		if High < c {
+			// There is usually a small difference between languages across regions.
+			c = High
+		}
+	}
+
+	// We store the results of the computations of the tie-breaker rules along
+	// with the best match. There is no need to do the checks once we determine
+	// we have a winner, but we do still need to do the tie-breaker computations.
+	// We use "beaten" to keep track if we still need to do the checks.
+	beaten := false // true if the new pair defeats the current one.
+	if c != m.conf {
+		if c < m.conf {
+			return
+		}
+		beaten = true
+	}
+
+	// Tie-breaker rules:
+	// We prefer if the pre-maximized language was specified and identical.
+	origLang := have.tag.LangID == tag.LangID && tag.LangID != 0
+	if !beaten && m.origLang != origLang {
+		if m.origLang {
+			return
+		}
+		beaten = true
+	}
+
+	// We prefer if the pre-maximized region was specified and identical.
+	origReg := have.tag.RegionID == tag.RegionID && tag.RegionID != 0
+	if !beaten && m.origReg != origReg {
+		if m.origReg {
+			return
+		}
+		beaten = true
+	}
+
+	regGroupDist, sameGroup := regionGroupDist(have.maxRegion, maxRegion, maxScript, tag.LangID)
+	if !beaten && m.regGroupDist != regGroupDist {
+		if regGroupDist > m.regGroupDist {
+			return
+		}
+		beaten = true
+	}
+
+	paradigmReg := isParadigmLocale(tag.LangID, have.maxRegion)
+	if !beaten && m.paradigmReg != paradigmReg {
+		if !paradigmReg {
+			return
+		}
+		beaten = true
+	}
+
+	// Next we prefer if the pre-maximized script was specified and identical.
+	origScript := have.tag.ScriptID == tag.ScriptID && tag.ScriptID != 0
+	if !beaten && m.origScript != origScript {
+		if m.origScript {
+			return
+		}
+		beaten = true
+	}
+
+	// Update m to the newly found best match.
+	if beaten {
+		m.have = have
+		m.want = tag
+		m.conf = c
+		m.pinnedRegion = maxRegion
+		m.sameRegionGroup = sameGroup
+		m.origLang = origLang
+		m.origReg = origReg
+		m.paradigmReg = paradigmReg
+		m.origScript = origScript
+		m.regGroupDist = regGroupDist
+	}
+}
+
+func isParadigmLocale(lang language.Language, r language.Region) bool {
+	for _, e := range paradigmLocales {
+		if language.Language(e[0]) == lang && (r == language.Region(e[1]) || r == language.Region(e[2])) {
+			return true
+		}
+	}
+	return false
+}
+
+// regionGroupDist computes the distance between two regions based on their
+// CLDR grouping.
+func regionGroupDist(a, b language.Region, script language.Script, lang language.Language) (dist uint8, same bool) {
+	const defaultDistance = 4
+
+	aGroup := uint(regionToGroups[a]) << 1
+	bGroup := uint(regionToGroups[b]) << 1
+	for _, ri := range matchRegion {
+		if language.Language(ri.lang) == lang && (ri.script == 0 || language.Script(ri.script) == script) {
+			group := uint(1 << (ri.group &^ 0x80))
+			if 0x80&ri.group == 0 {
+				if aGroup&bGroup&group != 0 { // Both regions are in the group.
+					return ri.distance, ri.distance == defaultDistance
+				}
+			} else {
+				if (aGroup|bGroup)&group == 0 { // Both regions are not in the group.
+					return ri.distance, ri.distance == defaultDistance
+				}
+			}
+		}
+	}
+	return defaultDistance, true
+}
+
+// equalsRest compares everything except the language.
+func equalsRest(a, b language.Tag) bool {
+	// TODO: don't include extensions in this comparison. To do this efficiently,
+	// though, we should handle private tags separately.
+	return a.ScriptID == b.ScriptID && a.RegionID == b.RegionID && a.VariantOrPrivateUseTags() == b.VariantOrPrivateUseTags()
+}
+
+// isExactEquivalent returns true if canonicalizing the language will not alter
+// the script or region of a tag.
+func isExactEquivalent(l language.Language) bool {
+	for _, o := range notEquivalent {
+		if o == l {
+			return false
+		}
+	}
+	return true
+}
+
+var notEquivalent []language.Language
+
+func init() {
+	// Create a list of all languages for which canonicalization may alter the
+	// script or region.
+	for _, lm := range language.AliasMap {
+		tag := language.Tag{LangID: language.Language(lm.From)}
+		if tag, _ = canonicalize(All, tag); tag.ScriptID != 0 || tag.RegionID != 0 {
+			notEquivalent = append(notEquivalent, language.Language(lm.From))
+		}
+	}
+	// Maximize undefined regions of paradigm locales.
+	for i, v := range paradigmLocales {
+		t := language.Tag{LangID: language.Language(v[0])}
+		max, _ := t.Maximize()
+		if v[1] == 0 {
+			paradigmLocales[i][1] = uint16(max.RegionID)
+		}
+		if v[2] == 0 {
+			paradigmLocales[i][2] = uint16(max.RegionID)
+		}
+	}
+}
diff --git a/vendor/golang.org/x/text/language/parse.go b/vendor/golang.org/x/text/language/parse.go
new file mode 100644
index 00000000000..053336e2866
--- /dev/null
+++ b/vendor/golang.org/x/text/language/parse.go
@@ -0,0 +1,256 @@
+// 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 language
+
+import (
+	"errors"
+	"sort"
+	"strconv"
+	"strings"
+
+	"golang.org/x/text/internal/language"
+)
+
+// ValueError is returned by any of the parsing functions when the
+// input is well-formed but the respective subtag is not recognized
+// as a valid value.
+type ValueError interface {
+	error
+
+	// Subtag returns the subtag for which the error occurred.
+	Subtag() string
+}
+
+// Parse parses the given BCP 47 string and returns a valid Tag. If parsing
+// failed it returns an error and any part of the tag that could be parsed.
+// If parsing succeeded but an unknown value was found, it returns
+// ValueError. The Tag returned in this case is just stripped of the unknown
+// value. All other values are preserved. It accepts tags in the BCP 47 format
+// and extensions to this standard defined in
+// https://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers.
+// The resulting tag is canonicalized using the default canonicalization type.
+func Parse(s string) (t Tag, err error) {
+	return Default.Parse(s)
+}
+
+// Parse parses the given BCP 47 string and returns a valid Tag. If parsing
+// failed it returns an error and any part of the tag that could be parsed.
+// If parsing succeeded but an unknown value was found, it returns
+// ValueError. The Tag returned in this case is just stripped of the unknown
+// value. All other values are preserved. It accepts tags in the BCP 47 format
+// and extensions to this standard defined in
+// https://www.unicode.org/reports/tr35/#Unicode_Language_and_Locale_Identifiers.
+// The resulting tag is canonicalized using the canonicalization type c.
+func (c CanonType) Parse(s string) (t Tag, err error) {
+	defer func() {
+		if recover() != nil {
+			t = Tag{}
+			err = language.ErrSyntax
+		}
+	}()
+
+	tt, err := language.Parse(s)
+	if err != nil {
+		return makeTag(tt), err
+	}
+	tt, changed := canonicalize(c, tt)
+	if changed {
+		tt.RemakeString()
+	}
+	return makeTag(tt), nil
+}
+
+// Compose creates a Tag from individual parts, which may be of type Tag, Base,
+// Script, Region, Variant, []Variant, Extension, []Extension or error. If a
+// Base, Script or Region or slice of type Variant or Extension is passed more
+// than once, the latter will overwrite the former. Variants and Extensions are
+// accumulated, but if two extensions of the same type are passed, the latter
+// will replace the former. For -u extensions, though, the key-type pairs are
+// added, where later values overwrite older ones. A Tag overwrites all former
+// values and typically only makes sense as the first argument. The resulting
+// tag is returned after canonicalizing using the Default CanonType. If one or
+// more errors are encountered, one of the errors is returned.
+func Compose(part ...interface{}) (t Tag, err error) {
+	return Default.Compose(part...)
+}
+
+// Compose creates a Tag from individual parts, which may be of type Tag, Base,
+// Script, Region, Variant, []Variant, Extension, []Extension or error. If a
+// Base, Script or Region or slice of type Variant or Extension is passed more
+// than once, the latter will overwrite the former. Variants and Extensions are
+// accumulated, but if two extensions of the same type are passed, the latter
+// will replace the former. For -u extensions, though, the key-type pairs are
+// added, where later values overwrite older ones. A Tag overwrites all former
+// values and typically only makes sense as the first argument. The resulting
+// tag is returned after canonicalizing using CanonType c. If one or more errors
+// are encountered, one of the errors is returned.
+func (c CanonType) Compose(part ...interface{}) (t Tag, err error) {
+	defer func() {
+		if recover() != nil {
+			t = Tag{}
+			err = language.ErrSyntax
+		}
+	}()
+
+	var b language.Builder
+	if err = update(&b, part...); err != nil {
+		return und, err
+	}
+	b.Tag, _ = canonicalize(c, b.Tag)
+	return makeTag(b.Make()), err
+}
+
+var errInvalidArgument = errors.New("invalid Extension or Variant")
+
+func update(b *language.Builder, part ...interface{}) (err error) {
+	for _, x := range part {
+		switch v := x.(type) {
+		case Tag:
+			b.SetTag(v.tag())
+		case Base:
+			b.Tag.LangID = v.langID
+		case Script:
+			b.Tag.ScriptID = v.scriptID
+		case Region:
+			b.Tag.RegionID = v.regionID
+		case Variant:
+			if v.variant == "" {
+				err = errInvalidArgument
+				break
+			}
+			b.AddVariant(v.variant)
+		case Extension:
+			if v.s == "" {
+				err = errInvalidArgument
+				break
+			}
+			b.SetExt(v.s)
+		case []Variant:
+			b.ClearVariants()
+			for _, v := range v {
+				b.AddVariant(v.variant)
+			}
+		case []Extension:
+			b.ClearExtensions()
+			for _, e := range v {
+				b.SetExt(e.s)
+			}
+		// TODO: support parsing of raw strings based on morphology or just extensions?
+		case error:
+			if v != nil {
+				err = v
+			}
+		}
+	}
+	return
+}
+
+var errInvalidWeight = errors.New("ParseAcceptLanguage: invalid weight")
+var errTagListTooLarge = errors.New("tag list exceeds max length")
+
+// ParseAcceptLanguage parses the contents of an Accept-Language header as
+// defined in http://www.ietf.org/rfc/rfc2616.txt and returns a list of Tags and
+// a list of corresponding quality weights. It is more permissive than RFC 2616
+// and may return non-nil slices even if the input is not valid.
+// The Tags will be sorted by highest weight first and then by first occurrence.
+// Tags with a weight of zero will be dropped. An error will be returned if the
+// input could not be parsed.
+func ParseAcceptLanguage(s string) (tag []Tag, q []float32, err error) {
+	defer func() {
+		if recover() != nil {
+			tag = nil
+			q = nil
+			err = language.ErrSyntax
+		}
+	}()
+
+	if strings.Count(s, "-") > 1000 {
+		return nil, nil, errTagListTooLarge
+	}
+
+	var entry string
+	for s != "" {
+		if entry, s = split(s, ','); entry == "" {
+			continue
+		}
+
+		entry, weight := split(entry, ';')
+
+		// Scan the language.
+		t, err := Parse(entry)
+		if err != nil {
+			id, ok := acceptFallback[entry]
+			if !ok {
+				return nil, nil, err
+			}
+			t = makeTag(language.Tag{LangID: id})
+		}
+
+		// Scan the optional weight.
+		w := 1.0
+		if weight != "" {
+			weight = consume(weight, 'q')
+			weight = consume(weight, '=')
+			// consume returns the empty string when a token could not be
+			// consumed, resulting in an error for ParseFloat.
+			if w, err = strconv.ParseFloat(weight, 32); err != nil {
+				return nil, nil, errInvalidWeight
+			}
+			// Drop tags with a quality weight of 0.
+			if w <= 0 {
+				continue
+			}
+		}
+
+		tag = append(tag, t)
+		q = append(q, float32(w))
+	}
+	sort.Stable(&tagSort{tag, q})
+	return tag, q, nil
+}
+
+// consume removes a leading token c from s and returns the result or the empty
+// string if there is no such token.
+func consume(s string, c byte) string {
+	if s == "" || s[0] != c {
+		return ""
+	}
+	return strings.TrimSpace(s[1:])
+}
+
+func split(s string, c byte) (head, tail string) {
+	if i := strings.IndexByte(s, c); i >= 0 {
+		return strings.TrimSpace(s[:i]), strings.TrimSpace(s[i+1:])
+	}
+	return strings.TrimSpace(s), ""
+}
+
+// Add hack mapping to deal with a small number of cases that occur
+// in Accept-Language (with reasonable frequency).
+var acceptFallback = map[string]language.Language{
+	"english": _en,
+	"deutsch": _de,
+	"italian": _it,
+	"french":  _fr,
+	"*":       _mul, // defined in the spec to match all languages.
+}
+
+type tagSort struct {
+	tag []Tag
+	q   []float32
+}
+
+func (s *tagSort) Len() int {
+	return len(s.q)
+}
+
+func (s *tagSort) Less(i, j int) bool {
+	return s.q[i] > s.q[j]
+}
+
+func (s *tagSort) Swap(i, j int) {
+	s.tag[i], s.tag[j] = s.tag[j], s.tag[i]
+	s.q[i], s.q[j] = s.q[j], s.q[i]
+}
diff --git a/vendor/golang.org/x/text/language/tables.go b/vendor/golang.org/x/text/language/tables.go
new file mode 100644
index 00000000000..a6573dcb215
--- /dev/null
+++ b/vendor/golang.org/x/text/language/tables.go
@@ -0,0 +1,298 @@
+// Code generated by running "go generate" in golang.org/x/text. DO NOT EDIT.
+
+package language
+
+// CLDRVersion is the CLDR version from which the tables in this package are derived.
+const CLDRVersion = "32"
+
+const (
+	_de  = 269
+	_en  = 313
+	_fr  = 350
+	_it  = 505
+	_mo  = 784
+	_no  = 879
+	_nb  = 839
+	_pt  = 960
+	_sh  = 1031
+	_mul = 806
+	_und = 0
+)
+const (
+	_001 = 1
+	_419 = 31
+	_BR  = 65
+	_CA  = 73
+	_ES  = 111
+	_GB  = 124
+	_MD  = 189
+	_PT  = 239
+	_UK  = 307
+	_US  = 310
+	_ZZ  = 358
+	_XA  = 324
+	_XC  = 326
+	_XK  = 334
+)
+const (
+	_Latn = 91
+	_Hani = 57
+	_Hans = 59
+	_Hant = 60
+	_Qaaa = 149
+	_Qaai = 157
+	_Qabx = 198
+	_Zinh = 255
+	_Zyyy = 260
+	_Zzzz = 261
+)
+
+var regionToGroups = []uint8{ // 359 elements
+	// Entry 0 - 3F
+	0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x04,
+	0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x04, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00,
+	0x00, 0x04, 0x00, 0x00, 0x04, 0x01, 0x00, 0x00,
+	0x04, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x04,
+	// Entry 40 - 7F
+	0x04, 0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x04, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x04, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04,
+	0x00, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x04, 0x00,
+	0x08, 0x00, 0x04, 0x00, 0x00, 0x08, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x04, 0x00, 0x04,
+	// Entry 80 - BF
+	0x00, 0x00, 0x00, 0x04, 0x00, 0x00, 0x04, 0x00,
+	0x00, 0x00, 0x04, 0x01, 0x00, 0x04, 0x02, 0x00,
+	0x04, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x04, 0x00,
+	0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x08, 0x08, 0x00, 0x00, 0x00, 0x04,
+	// Entry C0 - FF
+	0x00, 0x01, 0x00, 0x00, 0x00, 0x00, 0x00, 0x02,
+	0x01, 0x04, 0x08, 0x04, 0x00, 0x00, 0x00, 0x00,
+	0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x04, 0x00, 0x04, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x04, 0x00, 0x05, 0x00, 0x00,
+	0x00, 0x00, 0x04, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	// Entry 100 - 13F
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x04,
+	0x00, 0x00, 0x00, 0x04, 0x04, 0x00, 0x00, 0x00,
+	0x04, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x08, 0x00, 0x00, 0x00, 0x04, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x01, 0x00, 0x05, 0x04,
+	0x00, 0x00, 0x04, 0x00, 0x04, 0x04, 0x05, 0x00,
+	// Entry 140 - 17F
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+	0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
+} // Size: 383 bytes
+
+var paradigmLocales = [][3]uint16{ // 3 elements
+	0: [3]uint16{0x139, 0x0, 0x7c},
+	1: [3]uint16{0x13e, 0x0, 0x1f},
+	2: [3]uint16{0x3c0, 0x41, 0xef},
+} // Size: 42 bytes
+
+type mutualIntelligibility struct {
+	want     uint16
+	have     uint16
+	distance uint8
+	oneway   bool
+}
+type scriptIntelligibility struct {
+	wantLang   uint16
+	haveLang   uint16
+	wantScript uint8
+	haveScript uint8
+	distance   uint8
+}
+type regionIntelligibility struct {
+	lang     uint16
+	script   uint8
+	group    uint8
+	distance uint8
+}
+
+// matchLang holds pairs of langIDs of base languages that are typically
+// mutually intelligible. Each pair is associated with a confidence and
+// whether the intelligibility goes one or both ways.
+var matchLang = []mutualIntelligibility{ // 113 elements
+	0:   {want: 0x1d1, have: 0xb7, distance: 0x4, oneway: false},
+	1:   {want: 0x407, have: 0xb7, distance: 0x4, oneway: false},
+	2:   {want: 0x407, have: 0x1d1, distance: 0x4, oneway: false},
+	3:   {want: 0x407, have: 0x432, distance: 0x4, oneway: false},
+	4:   {want: 0x43a, have: 0x1, distance: 0x4, oneway: false},
+	5:   {want: 0x1a3, have: 0x10d, distance: 0x4, oneway: true},
+	6:   {want: 0x295, have: 0x10d, distance: 0x4, oneway: true},
+	7:   {want: 0x101, have: 0x36f, distance: 0x8, oneway: false},
+	8:   {want: 0x101, have: 0x347, distance: 0x8, oneway: false},
+	9:   {want: 0x5, have: 0x3e2, distance: 0xa, oneway: true},
+	10:  {want: 0xd, have: 0x139, distance: 0xa, oneway: true},
+	11:  {want: 0x16, have: 0x367, distance: 0xa, oneway: true},
+	12:  {want: 0x21, have: 0x139, distance: 0xa, oneway: true},
+	13:  {want: 0x56, have: 0x13e, distance: 0xa, oneway: true},
+	14:  {want: 0x58, have: 0x3e2, distance: 0xa, oneway: true},
+	15:  {want: 0x71, have: 0x3e2, distance: 0xa, oneway: true},
+	16:  {want: 0x75, have: 0x139, distance: 0xa, oneway: true},
+	17:  {want: 0x82, have: 0x1be, distance: 0xa, oneway: true},
+	18:  {want: 0xa5, have: 0x139, distance: 0xa, oneway: true},
+	19:  {want: 0xb2, have: 0x15e, distance: 0xa, oneway: true},
+	20:  {want: 0xdd, have: 0x153, distance: 0xa, oneway: true},
+	21:  {want: 0xe5, have: 0x139, distance: 0xa, oneway: true},
+	22:  {want: 0xe9, have: 0x3a, distance: 0xa, oneway: true},
+	23:  {want: 0xf0, have: 0x15e, distance: 0xa, oneway: true},
+	24:  {want: 0xf9, have: 0x15e, distance: 0xa, oneway: true},
+	25:  {want: 0x100, have: 0x139, distance: 0xa, oneway: true},
+	26:  {want: 0x130, have: 0x139, distance: 0xa, oneway: true},
+	27:  {want: 0x13c, have: 0x139, distance: 0xa, oneway: true},
+	28:  {want: 0x140, have: 0x151, distance: 0xa, oneway: true},
+	29:  {want: 0x145, have: 0x13e, distance: 0xa, oneway: true},
+	30:  {want: 0x158, have: 0x101, distance: 0xa, oneway: true},
+	31:  {want: 0x16d, have: 0x367, distance: 0xa, oneway: true},
+	32:  {want: 0x16e, have: 0x139, distance: 0xa, oneway: true},
+	33:  {want: 0x16f, have: 0x139, distance: 0xa, oneway: true},
+	34:  {want: 0x17e, have: 0x139, distance: 0xa, oneway: true},
+	35:  {want: 0x190, have: 0x13e, distance: 0xa, oneway: true},
+	36:  {want: 0x194, have: 0x13e, distance: 0xa, oneway: true},
+	37:  {want: 0x1a4, have: 0x1be, distance: 0xa, oneway: true},
+	38:  {want: 0x1b4, have: 0x139, distance: 0xa, oneway: true},
+	39:  {want: 0x1b8, have: 0x139, distance: 0xa, oneway: true},
+	40:  {want: 0x1d4, have: 0x15e, distance: 0xa, oneway: true},
+	41:  {want: 0x1d7, have: 0x3e2, distance: 0xa, oneway: true},
+	42:  {want: 0x1d9, have: 0x139, distance: 0xa, oneway: true},
+	43:  {want: 0x1e7, have: 0x139, distance: 0xa, oneway: true},
+	44:  {want: 0x1f8, have: 0x139, distance: 0xa, oneway: true},
+	45:  {want: 0x20e, have: 0x1e1, distance: 0xa, oneway: true},
+	46:  {want: 0x210, have: 0x139, distance: 0xa, oneway: true},
+	47:  {want: 0x22d, have: 0x15e, distance: 0xa, oneway: true},
+	48:  {want: 0x242, have: 0x3e2, distance: 0xa, oneway: true},
+	49:  {want: 0x24a, have: 0x139, distance: 0xa, oneway: true},
+	50:  {want: 0x251, have: 0x139, distance: 0xa, oneway: true},
+	51:  {want: 0x265, have: 0x139, distance: 0xa, oneway: true},
+	52:  {want: 0x274, have: 0x48a, distance: 0xa, oneway: true},
+	53:  {want: 0x28a, have: 0x3e2, distance: 0xa, oneway: true},
+	54:  {want: 0x28e, have: 0x1f9, distance: 0xa, oneway: true},
+	55:  {want: 0x2a3, have: 0x139, distance: 0xa, oneway: true},
+	56:  {want: 0x2b5, have: 0x15e, distance: 0xa, oneway: true},
+	57:  {want: 0x2b8, have: 0x139, distance: 0xa, oneway: true},
+	58:  {want: 0x2be, have: 0x139, distance: 0xa, oneway: true},
+	59:  {want: 0x2c3, have: 0x15e, distance: 0xa, oneway: true},
+	60:  {want: 0x2ed, have: 0x139, distance: 0xa, oneway: true},
+	61:  {want: 0x2f1, have: 0x15e, distance: 0xa, oneway: true},
+	62:  {want: 0x2fa, have: 0x139, distance: 0xa, oneway: true},
+	63:  {want: 0x2ff, have: 0x7e, distance: 0xa, oneway: true},
+	64:  {want: 0x304, have: 0x139, distance: 0xa, oneway: true},
+	65:  {want: 0x30b, have: 0x3e2, distance: 0xa, oneway: true},
+	66:  {want: 0x31b, have: 0x1be, distance: 0xa, oneway: true},
+	67:  {want: 0x31f, have: 0x1e1, distance: 0xa, oneway: true},
+	68:  {want: 0x320, have: 0x139, distance: 0xa, oneway: true},
+	69:  {want: 0x331, have: 0x139, distance: 0xa, oneway: true},
+	70:  {want: 0x351, have: 0x139, distance: 0xa, oneway: true},
+	71:  {want: 0x36a, have: 0x347, distance: 0xa, oneway: false},
+	72:  {want: 0x36a, have: 0x36f, distance: 0xa, oneway: true},
+	73:  {want: 0x37a, have: 0x139, distance: 0xa, oneway: true},
+	74:  {want: 0x387, have: 0x139, distance: 0xa, oneway: true},
+	75:  {want: 0x389, have: 0x139, distance: 0xa, oneway: true},
+	76:  {want: 0x38b, have: 0x15e, distance: 0xa, oneway: true},
+	77:  {want: 0x390, have: 0x139, distance: 0xa, oneway: true},
+	78:  {want: 0x395, have: 0x139, distance: 0xa, oneway: true},
+	79:  {want: 0x39d, have: 0x139, distance: 0xa, oneway: true},
+	80:  {want: 0x3a5, have: 0x139, distance: 0xa, oneway: true},
+	81:  {want: 0x3be, have: 0x139, distance: 0xa, oneway: true},
+	82:  {want: 0x3c4, have: 0x13e, distance: 0xa, oneway: true},
+	83:  {want: 0x3d4, have: 0x10d, distance: 0xa, oneway: true},
+	84:  {want: 0x3d9, have: 0x139, distance: 0xa, oneway: true},
+	85:  {want: 0x3e5, have: 0x15e, distance: 0xa, oneway: true},
+	86:  {want: 0x3e9, have: 0x1be, distance: 0xa, oneway: true},
+	87:  {want: 0x3fa, have: 0x139, distance: 0xa, oneway: true},
+	88:  {want: 0x40c, have: 0x139, distance: 0xa, oneway: true},
+	89:  {want: 0x423, have: 0x139, distance: 0xa, oneway: true},
+	90:  {want: 0x429, have: 0x139, distance: 0xa, oneway: true},
+	91:  {want: 0x431, have: 0x139, distance: 0xa, oneway: true},
+	92:  {want: 0x43b, have: 0x139, distance: 0xa, oneway: true},
+	93:  {want: 0x43e, have: 0x1e1, distance: 0xa, oneway: true},
+	94:  {want: 0x445, have: 0x139, distance: 0xa, oneway: true},
+	95:  {want: 0x450, have: 0x139, distance: 0xa, oneway: true},
+	96:  {want: 0x461, have: 0x139, distance: 0xa, oneway: true},
+	97:  {want: 0x467, have: 0x3e2, distance: 0xa, oneway: true},
+	98:  {want: 0x46f, have: 0x139, distance: 0xa, oneway: true},
+	99:  {want: 0x476, have: 0x3e2, distance: 0xa, oneway: true},
+	100: {want: 0x3883, have: 0x139, distance: 0xa, oneway: true},
+	101: {want: 0x480, have: 0x139, distance: 0xa, oneway: true},
+	102: {want: 0x482, have: 0x139, distance: 0xa, oneway: true},
+	103: {want: 0x494, have: 0x3e2, distance: 0xa, oneway: true},
+	104: {want: 0x49d, have: 0x139, distance: 0xa, oneway: true},
+	105: {want: 0x4ac, have: 0x529, distance: 0xa, oneway: true},
+	106: {want: 0x4b4, have: 0x139, distance: 0xa, oneway: true},
+	107: {want: 0x4bc, have: 0x3e2, distance: 0xa, oneway: true},
+	108: {want: 0x4e5, have: 0x15e, distance: 0xa, oneway: true},
+	109: {want: 0x4f2, have: 0x139, distance: 0xa, oneway: true},
+	110: {want: 0x512, have: 0x139, distance: 0xa, oneway: true},
+	111: {want: 0x518, have: 0x139, distance: 0xa, oneway: true},
+	112: {want: 0x52f, have: 0x139, distance: 0xa, oneway: true},
+} // Size: 702 bytes
+
+// matchScript holds pairs of scriptIDs where readers of one script
+// can typically also read the other. Each is associated with a confidence.
+var matchScript = []scriptIntelligibility{ // 26 elements
+	0:  {wantLang: 0x432, haveLang: 0x432, wantScript: 0x5b, haveScript: 0x20, distance: 0x5},
+	1:  {wantLang: 0x432, haveLang: 0x432, wantScript: 0x20, haveScript: 0x5b, distance: 0x5},
+	2:  {wantLang: 0x58, haveLang: 0x3e2, wantScript: 0x5b, haveScript: 0x20, distance: 0xa},
+	3:  {wantLang: 0xa5, haveLang: 0x139, wantScript: 0xe, haveScript: 0x5b, distance: 0xa},
+	4:  {wantLang: 0x1d7, haveLang: 0x3e2, wantScript: 0x8, haveScript: 0x20, distance: 0xa},
+	5:  {wantLang: 0x210, haveLang: 0x139, wantScript: 0x2e, haveScript: 0x5b, distance: 0xa},
+	6:  {wantLang: 0x24a, haveLang: 0x139, wantScript: 0x4f, haveScript: 0x5b, distance: 0xa},
+	7:  {wantLang: 0x251, haveLang: 0x139, wantScript: 0x53, haveScript: 0x5b, distance: 0xa},
+	8:  {wantLang: 0x2b8, haveLang: 0x139, wantScript: 0x58, haveScript: 0x5b, distance: 0xa},
+	9:  {wantLang: 0x304, haveLang: 0x139, wantScript: 0x6f, haveScript: 0x5b, distance: 0xa},
+	10: {wantLang: 0x331, haveLang: 0x139, wantScript: 0x76, haveScript: 0x5b, distance: 0xa},
+	11: {wantLang: 0x351, haveLang: 0x139, wantScript: 0x22, haveScript: 0x5b, distance: 0xa},
+	12: {wantLang: 0x395, haveLang: 0x139, wantScript: 0x83, haveScript: 0x5b, distance: 0xa},
+	13: {wantLang: 0x39d, haveLang: 0x139, wantScript: 0x36, haveScript: 0x5b, distance: 0xa},
+	14: {wantLang: 0x3be, haveLang: 0x139, wantScript: 0x5, haveScript: 0x5b, distance: 0xa},
+	15: {wantLang: 0x3fa, haveLang: 0x139, wantScript: 0x5, haveScript: 0x5b, distance: 0xa},
+	16: {wantLang: 0x40c, haveLang: 0x139, wantScript: 0xd6, haveScript: 0x5b, distance: 0xa},
+	17: {wantLang: 0x450, haveLang: 0x139, wantScript: 0xe6, haveScript: 0x5b, distance: 0xa},
+	18: {wantLang: 0x461, haveLang: 0x139, wantScript: 0xe9, haveScript: 0x5b, distance: 0xa},
+	19: {wantLang: 0x46f, haveLang: 0x139, wantScript: 0x2c, haveScript: 0x5b, distance: 0xa},
+	20: {wantLang: 0x476, haveLang: 0x3e2, wantScript: 0x5b, haveScript: 0x20, distance: 0xa},
+	21: {wantLang: 0x4b4, haveLang: 0x139, wantScript: 0x5, haveScript: 0x5b, distance: 0xa},
+	22: {wantLang: 0x4bc, haveLang: 0x3e2, wantScript: 0x5b, haveScript: 0x20, distance: 0xa},
+	23: {wantLang: 0x512, haveLang: 0x139, wantScript: 0x3e, haveScript: 0x5b, distance: 0xa},
+	24: {wantLang: 0x529, haveLang: 0x529, wantScript: 0x3b, haveScript: 0x3c, distance: 0xf},
+	25: {wantLang: 0x529, haveLang: 0x529, wantScript: 0x3c, haveScript: 0x3b, distance: 0x13},
+} // Size: 232 bytes
+
+var matchRegion = []regionIntelligibility{ // 15 elements
+	0:  {lang: 0x3a, script: 0x0, group: 0x4, distance: 0x4},
+	1:  {lang: 0x3a, script: 0x0, group: 0x84, distance: 0x4},
+	2:  {lang: 0x139, script: 0x0, group: 0x1, distance: 0x4},
+	3:  {lang: 0x139, script: 0x0, group: 0x81, distance: 0x4},
+	4:  {lang: 0x13e, script: 0x0, group: 0x3, distance: 0x4},
+	5:  {lang: 0x13e, script: 0x0, group: 0x83, distance: 0x4},
+	6:  {lang: 0x3c0, script: 0x0, group: 0x3, distance: 0x4},
+	7:  {lang: 0x3c0, script: 0x0, group: 0x83, distance: 0x4},
+	8:  {lang: 0x529, script: 0x3c, group: 0x2, distance: 0x4},
+	9:  {lang: 0x529, script: 0x3c, group: 0x82, distance: 0x4},
+	10: {lang: 0x3a, script: 0x0, group: 0x80, distance: 0x5},
+	11: {lang: 0x139, script: 0x0, group: 0x80, distance: 0x5},
+	12: {lang: 0x13e, script: 0x0, group: 0x80, distance: 0x5},
+	13: {lang: 0x3c0, script: 0x0, group: 0x80, distance: 0x5},
+	14: {lang: 0x529, script: 0x3c, group: 0x80, distance: 0x5},
+} // Size: 114 bytes
+
+// Total table size 1473 bytes (1KiB); checksum: 7BB90B5C
diff --git a/vendor/golang.org/x/text/language/tags.go b/vendor/golang.org/x/text/language/tags.go
new file mode 100644
index 00000000000..42ea7926660
--- /dev/null
+++ b/vendor/golang.org/x/text/language/tags.go
@@ -0,0 +1,145 @@
+// 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 language
+
+import "golang.org/x/text/internal/language/compact"
+
+// TODO: Various sets of commonly use tags and regions.
+
+// MustParse is like Parse, but panics if the given BCP 47 tag cannot be parsed.
+// It simplifies safe initialization of Tag values.
+func MustParse(s string) Tag {
+	t, err := Parse(s)
+	if err != nil {
+		panic(err)
+	}
+	return t
+}
+
+// MustParse is like Parse, but panics if the given BCP 47 tag cannot be parsed.
+// It simplifies safe initialization of Tag values.
+func (c CanonType) MustParse(s string) Tag {
+	t, err := c.Parse(s)
+	if err != nil {
+		panic(err)
+	}
+	return t
+}
+
+// MustParseBase is like ParseBase, but panics if the given base cannot be parsed.
+// It simplifies safe initialization of Base values.
+func MustParseBase(s string) Base {
+	b, err := ParseBase(s)
+	if err != nil {
+		panic(err)
+	}
+	return b
+}
+
+// MustParseScript is like ParseScript, but panics if the given script cannot be
+// parsed. It simplifies safe initialization of Script values.
+func MustParseScript(s string) Script {
+	scr, err := ParseScript(s)
+	if err != nil {
+		panic(err)
+	}
+	return scr
+}
+
+// MustParseRegion is like ParseRegion, but panics if the given region cannot be
+// parsed. It simplifies safe initialization of Region values.
+func MustParseRegion(s string) Region {
+	r, err := ParseRegion(s)
+	if err != nil {
+		panic(err)
+	}
+	return r
+}
+
+var (
+	und = Tag{}
+
+	Und Tag = Tag{}
+
+	Afrikaans            Tag = Tag(compact.Afrikaans)
+	Amharic              Tag = Tag(compact.Amharic)
+	Arabic               Tag = Tag(compact.Arabic)
+	ModernStandardArabic Tag = Tag(compact.ModernStandardArabic)
+	Azerbaijani          Tag = Tag(compact.Azerbaijani)
+	Bulgarian            Tag = Tag(compact.Bulgarian)
+	Bengali              Tag = Tag(compact.Bengali)
+	Catalan              Tag = Tag(compact.Catalan)
+	Czech                Tag = Tag(compact.Czech)
+	Danish               Tag = Tag(compact.Danish)
+	German               Tag = Tag(compact.German)
+	Greek                Tag = Tag(compact.Greek)
+	English              Tag = Tag(compact.English)
+	AmericanEnglish      Tag = Tag(compact.AmericanEnglish)
+	BritishEnglish       Tag = Tag(compact.BritishEnglish)
+	Spanish              Tag = Tag(compact.Spanish)
+	EuropeanSpanish      Tag = Tag(compact.EuropeanSpanish)
+	LatinAmericanSpanish Tag = Tag(compact.LatinAmericanSpanish)
+	Estonian             Tag = Tag(compact.Estonian)
+	Persian              Tag = Tag(compact.Persian)
+	Finnish              Tag = Tag(compact.Finnish)
+	Filipino             Tag = Tag(compact.Filipino)
+	French               Tag = Tag(compact.French)
+	CanadianFrench       Tag = Tag(compact.CanadianFrench)
+	Gujarati             Tag = Tag(compact.Gujarati)
+	Hebrew               Tag = Tag(compact.Hebrew)
+	Hindi                Tag = Tag(compact.Hindi)
+	Croatian             Tag = Tag(compact.Croatian)
+	Hungarian            Tag = Tag(compact.Hungarian)
+	Armenian             Tag = Tag(compact.Armenian)
+	Indonesian           Tag = Tag(compact.Indonesian)
+	Icelandic            Tag = Tag(compact.Icelandic)
+	Italian              Tag = Tag(compact.Italian)
+	Japanese             Tag = Tag(compact.Japanese)
+	Georgian             Tag = Tag(compact.Georgian)
+	Kazakh               Tag = Tag(compact.Kazakh)
+	Khmer                Tag = Tag(compact.Khmer)
+	Kannada              Tag = Tag(compact.Kannada)
+	Korean               Tag = Tag(compact.Korean)
+	Kirghiz              Tag = Tag(compact.Kirghiz)
+	Lao                  Tag = Tag(compact.Lao)
+	Lithuanian           Tag = Tag(compact.Lithuanian)
+	Latvian              Tag = Tag(compact.Latvian)
+	Macedonian           Tag = Tag(compact.Macedonian)
+	Malayalam            Tag = Tag(compact.Malayalam)
+	Mongolian            Tag = Tag(compact.Mongolian)
+	Marathi              Tag = Tag(compact.Marathi)
+	Malay                Tag = Tag(compact.Malay)
+	Burmese              Tag = Tag(compact.Burmese)
+	Nepali               Tag = Tag(compact.Nepali)
+	Dutch                Tag = Tag(compact.Dutch)
+	Norwegian            Tag = Tag(compact.Norwegian)
+	Punjabi              Tag = Tag(compact.Punjabi)
+	Polish               Tag = Tag(compact.Polish)
+	Portuguese           Tag = Tag(compact.Portuguese)
+	BrazilianPortuguese  Tag = Tag(compact.BrazilianPortuguese)
+	EuropeanPortuguese   Tag = Tag(compact.EuropeanPortuguese)
+	Romanian             Tag = Tag(compact.Romanian)
+	Russian              Tag = Tag(compact.Russian)
+	Sinhala              Tag = Tag(compact.Sinhala)
+	Slovak               Tag = Tag(compact.Slovak)
+	Slovenian            Tag = Tag(compact.Slovenian)
+	Albanian             Tag = Tag(compact.Albanian)
+	Serbian              Tag = Tag(compact.Serbian)
+	SerbianLatin         Tag = Tag(compact.SerbianLatin)
+	Swedish              Tag = Tag(compact.Swedish)
+	Swahili              Tag = Tag(compact.Swahili)
+	Tamil                Tag = Tag(compact.Tamil)
+	Telugu               Tag = Tag(compact.Telugu)
+	Thai                 Tag = Tag(compact.Thai)
+	Turkish              Tag = Tag(compact.Turkish)
+	Ukrainian            Tag = Tag(compact.Ukrainian)
+	Urdu                 Tag = Tag(compact.Urdu)
+	Uzbek                Tag = Tag(compact.Uzbek)
+	Vietnamese           Tag = Tag(compact.Vietnamese)
+	Chinese              Tag = Tag(compact.Chinese)
+	SimplifiedChinese    Tag = Tag(compact.SimplifiedChinese)
+	TraditionalChinese   Tag = Tag(compact.TraditionalChinese)
+	Zulu                 Tag = Tag(compact.Zulu)
+)
diff --git a/vendor/modules.txt b/vendor/modules.txt
index 6b8d32e6043..e096c202de7 100644
--- a/vendor/modules.txt
+++ b/vendor/modules.txt
@@ -159,9 +159,13 @@ github.com/rivo/uniseg
 # github.com/sahilm/fuzzy v0.1.1
 ## explicit
 github.com/sahilm/fuzzy
-# github.com/samber/lo v1.31.0
+# github.com/samber/lo v1.53.0
 ## explicit; go 1.18
 github.com/samber/lo
+github.com/samber/lo/internal/constraints
+github.com/samber/lo/internal/xrand
+github.com/samber/lo/internal/xtime
+github.com/samber/lo/mutable
 # github.com/sanity-io/litter v1.5.8
 ## explicit; go 1.16
 github.com/sanity-io/litter
@@ -211,8 +215,14 @@ golang.org/x/sys/windows
 golang.org/x/term
 # golang.org/x/text v0.35.0
 ## explicit; go 1.25.0
+golang.org/x/text/cases
 golang.org/x/text/encoding
 golang.org/x/text/encoding/internal/identifier
+golang.org/x/text/internal
+golang.org/x/text/internal/language
+golang.org/x/text/internal/language/compact
+golang.org/x/text/internal/tag
+golang.org/x/text/language
 golang.org/x/text/runes
 golang.org/x/text/transform
 golang.org/x/text/unicode/norm